version = "0.1.0"
dependencies = [
"advapi32-sys 0.0.4 (registry+https://github.com/rust-lang/crates.io-index)",
- "curl 0.2.3 (registry+https://github.com/rust-lang/crates.io-index)",
- "docopt 0.6.52 (registry+https://github.com/rust-lang/crates.io-index)",
- "env_logger 0.2.3 (registry+https://github.com/rust-lang/crates.io-index)",
- "flate2 0.2.0 (registry+https://github.com/rust-lang/crates.io-index)",
- "git2 0.2.5 (registry+https://github.com/rust-lang/crates.io-index)",
- "git2-curl 0.2.1 (registry+https://github.com/rust-lang/crates.io-index)",
- "glob 0.2.6 (registry+https://github.com/rust-lang/crates.io-index)",
+ "curl 0.2.4 (registry+https://github.com/rust-lang/crates.io-index)",
+ "docopt 0.6.54 (registry+https://github.com/rust-lang/crates.io-index)",
+ "env_logger 0.3.0 (registry+https://github.com/rust-lang/crates.io-index)",
+ "flate2 0.2.1 (registry+https://github.com/rust-lang/crates.io-index)",
+ "git2 0.2.6 (registry+https://github.com/rust-lang/crates.io-index)",
+ "git2-curl 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)",
+ "glob 0.2.7 (registry+https://github.com/rust-lang/crates.io-index)",
"hamcrest 0.1.0 (git+https://github.com/carllerche/hamcrest-rust.git)",
"kernel32-sys 0.0.11 (registry+https://github.com/rust-lang/crates.io-index)",
"libc 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)",
- "log 0.2.6 (registry+https://github.com/rust-lang/crates.io-index)",
- "regex 0.1.20 (registry+https://github.com/rust-lang/crates.io-index)",
+ "log 0.3.0 (registry+https://github.com/rust-lang/crates.io-index)",
+ "regex 0.1.21 (registry+https://github.com/rust-lang/crates.io-index)",
"registry 0.1.0",
- "rustc-serialize 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)",
- "semver 0.1.16 (registry+https://github.com/rust-lang/crates.io-index)",
+ "rustc-serialize 0.3.7 (registry+https://github.com/rust-lang/crates.io-index)",
+ "semver 0.1.17 (registry+https://github.com/rust-lang/crates.io-index)",
"tar 0.2.6 (registry+https://github.com/rust-lang/crates.io-index)",
- "tempdir 0.3.2 (registry+https://github.com/rust-lang/crates.io-index)",
- "term 0.2.1 (registry+https://github.com/rust-lang/crates.io-index)",
+ "tempdir 0.3.3 (registry+https://github.com/rust-lang/crates.io-index)",
+ "term 0.2.3 (registry+https://github.com/rust-lang/crates.io-index)",
"threadpool 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)",
"time 0.1.21 (registry+https://github.com/rust-lang/crates.io-index)",
- "toml 0.1.18 (registry+https://github.com/rust-lang/crates.io-index)",
- "url 0.2.27 (registry+https://github.com/rust-lang/crates.io-index)",
+ "toml 0.1.19 (registry+https://github.com/rust-lang/crates.io-index)",
+ "url 0.2.28 (registry+https://github.com/rust-lang/crates.io-index)",
"winapi 0.1.15 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "curl"
-version = "0.2.3"
+version = "0.2.4"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
- "curl-sys 0.1.16 (registry+https://github.com/rust-lang/crates.io-index)",
+ "curl-sys 0.1.17 (registry+https://github.com/rust-lang/crates.io-index)",
"libc 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)",
- "openssl-sys 0.5.1 (registry+https://github.com/rust-lang/crates.io-index)",
- "url 0.2.27 (registry+https://github.com/rust-lang/crates.io-index)",
+ "openssl-sys 0.5.2 (registry+https://github.com/rust-lang/crates.io-index)",
+ "url 0.2.28 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "curl-sys"
-version = "0.1.16"
+version = "0.1.17"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
"libc 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)",
- "libz-sys 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)",
- "openssl-sys 0.5.1 (registry+https://github.com/rust-lang/crates.io-index)",
- "pkg-config 0.3.1 (registry+https://github.com/rust-lang/crates.io-index)",
+ "libz-sys 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)",
+ "openssl-sys 0.5.2 (registry+https://github.com/rust-lang/crates.io-index)",
+ "pkg-config 0.3.2 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "docopt"
-version = "0.6.52"
+version = "0.6.54"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
"libc 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)",
- "regex 0.1.20 (registry+https://github.com/rust-lang/crates.io-index)",
- "rustc-serialize 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)",
+ "regex 0.1.21 (registry+https://github.com/rust-lang/crates.io-index)",
+ "rustc-serialize 0.3.7 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "env_logger"
-version = "0.2.3"
+version = "0.3.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
- "log 0.2.6 (registry+https://github.com/rust-lang/crates.io-index)",
- "regex 0.1.20 (registry+https://github.com/rust-lang/crates.io-index)",
+ "log 0.3.0 (registry+https://github.com/rust-lang/crates.io-index)",
+ "regex 0.1.21 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "flate2"
-version = "0.2.0"
+version = "0.2.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
"libc 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)",
- "miniz-sys 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)",
+ "miniz-sys 0.1.4 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "gcc"
-version = "0.3.2"
+version = "0.3.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
[[package]]
name = "git2"
-version = "0.2.5"
+version = "0.2.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
"bitflags 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)",
"libc 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)",
- "libgit2-sys 0.2.5 (registry+https://github.com/rust-lang/crates.io-index)",
- "url 0.2.27 (registry+https://github.com/rust-lang/crates.io-index)",
+ "libgit2-sys 0.2.7 (registry+https://github.com/rust-lang/crates.io-index)",
+ "url 0.2.28 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "git2-curl"
-version = "0.2.1"
+version = "0.2.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
- "curl 0.2.3 (registry+https://github.com/rust-lang/crates.io-index)",
- "git2 0.2.5 (registry+https://github.com/rust-lang/crates.io-index)",
- "log 0.2.6 (registry+https://github.com/rust-lang/crates.io-index)",
- "url 0.2.27 (registry+https://github.com/rust-lang/crates.io-index)",
+ "curl 0.2.4 (registry+https://github.com/rust-lang/crates.io-index)",
+ "git2 0.2.6 (registry+https://github.com/rust-lang/crates.io-index)",
+ "log 0.3.0 (registry+https://github.com/rust-lang/crates.io-index)",
+ "url 0.2.28 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "glob"
-version = "0.2.6"
+version = "0.2.7"
source = "registry+https://github.com/rust-lang/crates.io-index"
[[package]]
name = "hamcrest"
version = "0.1.0"
-source = "git+https://github.com/carllerche/hamcrest-rust.git#27a3368a915aabdee09c9f2c515127689715c1d9"
+source = "git+https://github.com/carllerche/hamcrest-rust.git#2dbf32e738935f7ebb5223b31b8fc1fe6327adf8"
[[package]]
name = "kernel32-sys"
[[package]]
name = "libgit2-sys"
-version = "0.2.5"
+version = "0.2.7"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
"libc 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)",
- "libssh2-sys 0.1.13 (registry+https://github.com/rust-lang/crates.io-index)",
- "libz-sys 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)",
- "openssl-sys 0.5.1 (registry+https://github.com/rust-lang/crates.io-index)",
- "pkg-config 0.3.1 (registry+https://github.com/rust-lang/crates.io-index)",
+ "libssh2-sys 0.1.15 (registry+https://github.com/rust-lang/crates.io-index)",
+ "libz-sys 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)",
+ "openssl-sys 0.5.2 (registry+https://github.com/rust-lang/crates.io-index)",
+ "pkg-config 0.3.2 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
[[package]]
name = "libssh2-sys"
-version = "0.1.13"
+version = "0.1.15"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
"libc 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)",
- "libz-sys 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)",
- "openssl-sys 0.5.1 (registry+https://github.com/rust-lang/crates.io-index)",
- "pkg-config 0.3.1 (registry+https://github.com/rust-lang/crates.io-index)",
+ "libz-sys 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)",
+ "openssl-sys 0.5.2 (registry+https://github.com/rust-lang/crates.io-index)",
+ "pkg-config 0.3.2 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "libz-sys"
-version = "0.1.1"
+version = "0.1.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
- "pkg-config 0.3.1 (registry+https://github.com/rust-lang/crates.io-index)",
+ "pkg-config 0.3.2 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "log"
-version = "0.2.6"
+version = "0.3.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
"libc 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)",
[[package]]
name = "miniz-sys"
-version = "0.1.3"
+version = "0.1.4"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
- "gcc 0.3.2 (registry+https://github.com/rust-lang/crates.io-index)",
+ "gcc 0.3.3 (registry+https://github.com/rust-lang/crates.io-index)",
"libc 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "openssl-sys"
-version = "0.5.1"
+version = "0.5.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
- "gcc 0.3.2 (registry+https://github.com/rust-lang/crates.io-index)",
+ "gcc 0.3.3 (registry+https://github.com/rust-lang/crates.io-index)",
"libc 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)",
"libressl-pnacl-sys 2.1.4 (registry+https://github.com/rust-lang/crates.io-index)",
- "pkg-config 0.3.1 (registry+https://github.com/rust-lang/crates.io-index)",
+ "pkg-config 0.3.2 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "pkg-config"
-version = "0.3.1"
+version = "0.3.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
[[package]]
[[package]]
name = "rand"
-version = "0.2.1"
+version = "0.3.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
"libc 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)",
- "log 0.2.6 (registry+https://github.com/rust-lang/crates.io-index)",
+ "log 0.3.0 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "regex"
-version = "0.1.20"
+version = "0.1.21"
source = "registry+https://github.com/rust-lang/crates.io-index"
[[package]]
name = "registry"
version = "0.1.0"
dependencies = [
- "curl 0.2.3 (registry+https://github.com/rust-lang/crates.io-index)",
- "rustc-serialize 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)",
+ "curl 0.2.4 (registry+https://github.com/rust-lang/crates.io-index)",
+ "rustc-serialize 0.3.7 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "rustc-serialize"
-version = "0.3.6"
+version = "0.3.7"
source = "registry+https://github.com/rust-lang/crates.io-index"
[[package]]
name = "semver"
-version = "0.1.16"
+version = "0.1.17"
source = "registry+https://github.com/rust-lang/crates.io-index"
[[package]]
[[package]]
name = "tempdir"
-version = "0.3.2"
+version = "0.3.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
- "rand 0.2.1 (registry+https://github.com/rust-lang/crates.io-index)",
+ "rand 0.3.3 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "term"
-version = "0.2.1"
+version = "0.2.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
"kernel32-sys 0.0.11 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.1.21"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
- "gcc 0.3.2 (registry+https://github.com/rust-lang/crates.io-index)",
+ "gcc 0.3.3 (registry+https://github.com/rust-lang/crates.io-index)",
"libc 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "toml"
-version = "0.1.18"
+version = "0.1.19"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
- "rustc-serialize 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)",
+ "rustc-serialize 0.3.7 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "url"
-version = "0.2.27"
+version = "0.2.28"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
"matches 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)",
- "rustc-serialize 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)",
+ "rustc-serialize 0.3.7 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
git2-curl = "0.2.1"
glob = "0.2.2"
time = "0.1.19"
-log = "0.2.5"
-env_logger = "0.2.2"
+log = "0.3.0"
+env_logger = "0.3"
docopt = "0.6.45"
url = "0.2.23"
rustc-serialize = "0.3.1"
#![feature(core, exit_status, fs_ext)]
-extern crate "git2-curl" as git2_curl;
-extern crate "rustc-serialize" as rustc_serialize;
extern crate cargo;
extern crate env_logger;
+extern crate git2_curl;
+extern crate rustc_serialize;
extern crate toml;
#[macro_use] extern crate log;
pub fn source_id(&self) -> &SourceId { &self.source_id }
pub fn kind(&self) -> Kind { self.kind }
pub fn specified_req(&self) -> Option<&str> {
- self.specified_req.as_ref().map(|s| s.as_slice())
+ self.specified_req.as_ref().map(|s| &s[..])
}
/// If none, this dependencies must be built for all platforms.
/// If some, it must only be built for the specified platform.
pub fn only_for_platform(&self) -> Option<&str> {
- self.only_for_platform.as_ref().map(|s| s.as_slice())
+ self.only_for_platform.as_ref().map(|s| &s[..])
}
pub fn set_kind(mut self, kind: Kind) -> Dependency {
pub fn warnings(&self) -> &[String] { &self.warnings }
pub fn profiles(&self) -> &Profiles { &self.profiles }
pub fn links(&self) -> Option<&str> {
- self.links.as_ref().map(|s| s.as_slice())
+ self.links.as_ref().map(|s| &s[..])
}
pub fn add_warning(&mut self, s: String) {
Target {
kind: TargetKind::Bin,
name: String::new(),
- src_path: PathBuf::new(""),
+ src_path: PathBuf::new(),
metadata: None,
doc: false,
doctest: false,
let key = (dep.name().to_string(), dep.source_id().clone());
let prev_active = cx.activations.get(&key)
- .map(|v| v.as_slice()).unwrap_or(&[]);
+ .map(|v| &v[..]).unwrap_or(&[]);
trace!("{}[{}]>{} {} candidates", parent.name(), cur, dep.name(),
candidates.len());
trace!("{}[{}]>{} {} prev activations", parent.name(), cur,
// features are bugs in that the package does not actually have those
// features.
if feature_deps.len() > 0 {
- let unknown = feature_deps.keys().map(|s| s.as_slice())
+ let unknown = feature_deps.keys().map(|s| &s[..])
.collect::<Vec<&str>>();
if unknown.len() > 0 {
let features = unknown.connect(", ");
let mut reference = GitReference::Branch("master".to_string());
let pairs = url.query_pairs().unwrap_or(Vec::new());
for &(ref k, ref v) in pairs.iter() {
- match k.as_slice() {
+ match &k[..] {
// map older 'ref' to branch
"branch" |
"ref" => reference = GitReference::Branch(v.clone()),
pub fn load<'a>(&self, config: &'a Config) -> Box<Source+'a> {
trace!("loading SourceId; {}", self);
match self.inner.kind {
- Kind::Git(..) => Box::new(GitSource::new(self, config)) as Box<Source>,
+ Kind::Git(..) => Box::new(GitSource::new(self, config)),
Kind::Path => {
let path = match self.inner.url.to_file_path() {
Ok(p) => p,
Err(()) => panic!("path sources cannot be remote"),
};
- Box::new(PathSource::new(&path, self, config)) as Box<Source>
- },
- Kind::Registry => {
- Box::new(RegistrySource::new(self, config)) as Box<Source>
+ Box::new(PathSource::new(&path, self, config))
}
+ Kind::Registry => Box::new(RegistrySource::new(self, config)),
}
}
pub fn precise(&self) -> Option<&str> {
- self.inner.precise.as_ref().map(|s| s.as_slice())
+ self.inner.precise.as_ref().map(|s| &s[..])
}
pub fn git_reference(&self) -> Option<&GitReference> {
fn fingerprint(&self, id: &Package) -> CargoResult<String> {
let mut ret = String::new();
for source in self.sources.iter() {
- ret.push_str(try!(source.fingerprint(id)).as_slice());
+ ret.push_str(&try!(source.fingerprint(id))[..]);
}
- return Ok(ret);
+ Ok(ret)
}
}
#![deny(unused)]
-#![feature(hash, os, std_misc, core, path_relative_from)]
-#![feature(io, str_words, exit_status, fs_time)]
+#![feature(os, std_misc, core, path_relative_from)]
+#![feature(io, str_words, exit_status, fs_time, convert)]
#![cfg_attr(test, deny(warnings))]
#[cfg(test)] extern crate hamcrest;
#[macro_use] extern crate log;
-extern crate "rustc-serialize" as rustc_serialize;
+extern crate rustc_serialize;
extern crate curl;
extern crate docopt;
extern crate flate2;
}
#[cfg(windows)]
fn isatty(fd: libc::c_int) -> bool {
- extern crate "kernel32-sys" as kernel32;
+ extern crate kernel32_sys as kernel32;
extern crate winapi;
unsafe {
let handle = kernel32::GetStdHandle(if fd == libc::STDOUT_FILENO {
{
let docopt = Docopt::new(usage).unwrap()
.options_first(options_first)
- .argv(args.iter().map(|s| s.as_slice()))
+ .argv(args.iter().map(|s| &s[..]))
.help(true)
.version(Some(version()));
docopt.decode().map_err(|e| {
output.library_links.extend(a.into_iter().map(|v| v.0));
} else if k == "rustc-link-search" {
output.library_paths.extend(a.into_iter().map(|v| {
- PathBuf::new(&v.0)
+ PathBuf::from(&v.0)
}));
} else {
try!(config.expected("string", &k,
impl Decodable for VersionControl {
fn decode<D: Decoder>(d: &mut D) -> Result<VersionControl, D::Error> {
- Ok(match try!(d.read_str()).as_slice() {
+ Ok(match &try!(d.read_str())[..] {
"git" => VersionControl::Git,
"hg" => VersionControl::Hg,
"none" => VersionControl::NoVcs,
Compilation {
libraries: HashMap::new(),
native_dirs: HashMap::new(), // TODO: deprecated, remove
- root_output: PathBuf::new("/"),
- deps_output: PathBuf::new("/"),
+ root_output: PathBuf::from("/"),
+ deps_output: PathBuf::from("/"),
tests: Vec::new(),
binaries: Vec::new(),
extra_env: HashMap::new(),
};
let target_triple = target.unwrap_or(config.rustc_host()).to_string();
let engine = build_config.exec_engine.as_ref().cloned().unwrap_or({
- Arc::new(Box::new(ProcessEngine) as Box<ExecEngine>)
+ Arc::new(Box::new(ProcessEngine))
});
Ok(Context {
target_triple: target_triple,
let (triple, pair) = if kind == Kind::Host {
(self.config.rustc_host(), &self.host_dylib)
} else {
- (self.target_triple.as_slice(), &self.target_dylib)
+ (&self.target_triple[..], &self.target_dylib)
};
match *pair {
None => return Err(human(format!("dylib outputs are not supported \
/// Get the user-specified linker for a particular host or target
pub fn linker(&self, kind: Kind) -> Option<&str> {
- self.target_config(kind).linker.as_ref().map(|s| s.as_slice())
+ self.target_config(kind).linker.as_ref().map(|s| &s[..])
}
/// Get the user-specified `ar` program for a particular host or target
pub fn ar(&self, kind: Kind) -> Option<&str> {
- self.target_config(kind).ar.as_ref().map(|s| s.as_slice())
+ self.target_config(kind).ar.as_ref().map(|s| &s[..])
}
/// Get the target configuration for a particular host or target
{
let build_state = build_state.outputs.lock().unwrap();
for &(ref name, ref id) in lib_deps.iter() {
- let data = &build_state[(id.clone(), kind)].metadata;
+ let data = &build_state[&(id.clone(), kind)].metadata;
for &(ref key, ref value) in data.iter() {
p.env(&format!("DEP_{}_{}", super::envify(name),
super::envify(key)), value);
} else if key == "rustc-link-lib" {
library_links.push(value.to_string());
} else if key == "rustc-link-search" {
- library_paths.push(PathBuf::new(&value));
+ library_paths.push(PathBuf::from(value));
} else {
metadata.push((key.to_string(), value.to_string()))
}
};
match flag {
"-l" => library_links.push(value.to_string()),
- "-L" => library_paths.push(PathBuf::new(value)),
+ "-L" => library_paths.push(PathBuf::from(value)),
// was already checked above
_ => return Err(human("only -l and -L flags are allowed"))
current_id: &PackageId) {
for id in native_lib_deps.into_iter() {
debug!("looking up {} {:?}", id, kind);
- let output = &build_state[(id.clone(), kind)];
+ let output = &build_state[&(id.clone(), kind)];
for path in output.library_paths.iter() {
rustc.arg("-L").arg(path);
}
let mut search_path = env::split_paths(&search_path).collect::<Vec<_>>();
for id in plugin_deps.into_iter() {
debug!("adding libs for plugin dep: {}", id);
- let output = &build_state[(id, Kind::Host)];
+ let output = &build_state[&(id, Kind::Host)];
for path in output.library_paths.iter() {
search_path.push(path.clone());
}
-> CargoResult<()> {
let layout = cx.layout(package, kind);
cmd.arg("-L").arg(&{
- let mut root = OsString::from_str("dependency=");
+ let mut root = OsString::from("dependency=");
root.push(layout.root());
root
});
cmd.arg("-L").arg(&{
- let mut deps = OsString::from_str("dependency=");
+ let mut deps = OsString::from("dependency=");
deps.push(layout.deps());
deps
});
for (pkg, libs) in compile.libraries.iter() {
for lib in libs.iter() {
- let mut arg = OsString::from_str(pkg.name());
+ let mut arg = OsString::from(pkg.name());
arg.push("=");
arg.push(lib);
p.arg("--extern").arg(&arg);
map.insert("token".to_string(), ConfigValue::String(token, p));
config::set_config(config, Location::Global, "registry",
- ConfigValue::Table(map, PathBuf::new(".")))
+ ConfigValue::Table(map, PathBuf::from(".")))
}
pub struct OwnersOptions {
match opts.to_add {
Some(ref v) => {
- let v = v.iter().map(|s| s.as_slice()).collect::<Vec<_>>();
+ let v = v.iter().map(|s| &s[..]).collect::<Vec<_>>();
try!(config.shell().status("Owner", format!("adding `{:#?}` to `{}`",
v, name)));
try!(registry.add_owners(&name, &v).map_err(|e| {
match opts.to_remove {
Some(ref v) => {
- let v = v.iter().map(|s| s.as_slice()).collect::<Vec<_>>();
+ let v = v.iter().map(|s| &s[..]).collect::<Vec<_>>();
try!(config.shell().status("Owner", format!("removing `{:?}` from `{}`",
v, name)));
try!(registry.remove_owners(&name, &v).map_err(|e| {
match url.scheme_data {
url::SchemeData::Relative(ref mut rel) => {
let needs_chopping = {
- let last = rel.path.last().map(|s| s.as_slice()).unwrap_or("");
+ let last = rel.path.last().map(|s| &s[..]).unwrap_or("");
last.ends_with(".git")
};
if needs_chopping {
let dep = try!(Dependency::parse(&name, Some(&req),
&self.source_id));
- let kind = match kind.as_ref().map(|s| s.as_slice()).unwrap_or("") {
+ let kind = match kind.as_ref().map(|s| &s[..]).unwrap_or("") {
"dev" => Kind::Development,
"build" => Kind::Build,
_ => Kind::Normal,
}
fn load_values(&self) -> CargoResult<()> {
- let mut cfg = CV::Table(HashMap::new(), PathBuf::new("."));
+ let mut cfg = CV::Table(HashMap::new(), PathBuf::from("."));
try!(walk_tree(&self.cwd, |mut file, path| {
let mut contents = String::new();
}
fn homedir() -> Option<PathBuf> {
- let cargo_home = env::var_os("CARGO_HOME").map(|p| PathBuf::new(&p));
+ let cargo_home = env::var_os("CARGO_HOME").map(PathBuf::from);
let user_home = env::home_dir().map(|p| p.join(".cargo"));
return cargo_home.or(user_home);
}
if fresh == Dirty {
self.dirty.insert(dep.clone());
}
- assert!(self.dep_map[*dep].0.remove(key));
+ assert!(self.dep_map.get_mut(dep).unwrap().0.remove(key));
}
}
}
fn cargo_cause(&self) -> Option<&CargoError>{ None }
}
-impl fmt::Debug for Box<CargoError> {
- fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
- fmt::Display::fmt(self, f)
- }
-}
-
impl Error for Box<CargoError> {
fn description(&self) -> &str { (**self).description() }
fn cause(&self) -> Option<&Error> { (**self).cause() }
where E: CargoError, F: FnOnce() -> E;
}
+#[derive(Debug)]
struct ChainedError<E> {
error: E,
cause: Box<CargoError>,
}
impl<T, E: CargoError + 'static> ChainError<T> for Result<T, E> {
+ #[allow(trivial_casts)]
fn chain_error<E2: 'static, C>(self, callback: C) -> CargoResult<T>
where E2: CargoError, C: FnOnce() -> E2 {
self.map_err(move |err| {
Err(Box::new(ChainedError {
error: callback(),
cause: self,
- }) as Box<CargoError>)
+ }))
}
}
where E: CargoError, C: FnOnce() -> E {
match self {
Some(t) => Ok(t),
- None => Err(Box::new(callback()) as Box<CargoError>),
+ None => Err(Box::new(callback())),
}
}
}
impl Error for ProcessError {
fn description(&self) -> &str { &self.desc }
+ #[allow(trivial_casts)]
fn cause(&self) -> Option<&Error> {
self.cause.as_ref().map(|s| s as &Error)
}
// =============================================================================
// Human errors
+#[derive(Debug)]
pub struct Human<E>(pub E);
impl<E: Error> Error for Human<E> {
}
pub fn from_error<E: CargoError>(error: E, code: i32) -> CliError {
- let error = Box::new(error) as Box<CargoError>;
+ let error = Box::new(error);
CliError::from_boxed(error, code)
}
Box::new(ConcreteCargoError {
description: error.to_string(),
detail: None,
- cause: Some(Box::new(cause) as Box<Error + Send>),
+ cause: Some(Box::new(cause)),
is_human: true
})
}
marks.insert(node.clone(), Mark::InProgress);
- for child in self.nodes[*node].iter() {
+ for child in self.nodes[node].iter() {
self.visit(child, dst, marks);
}
let mut ret = if let Some(c @ Component::Prefix(..)) = components.peek()
.cloned() {
components.next();
- PathBuf::new(c.as_os_str())
+ PathBuf::from(c.as_os_str())
} else {
- PathBuf::new("")
+ PathBuf::new()
};
for component in components {
pub fn bytes2path(bytes: &[u8]) -> CargoResult<PathBuf> {
use std::os::unix::prelude::*;
use std::ffi::OsStr;
- Ok(PathBuf::new(<OsStr as OsStrExt>::from_bytes(bytes)))
+ Ok(PathBuf::from(OsStr::from_bytes(bytes)))
}
#[cfg(windows)]
pub fn bytes2path(bytes: &[u8]) -> CargoResult<PathBuf> {
use std::str;
match str::from_utf8(bytes) {
- Ok(s) => Ok(PathBuf::new(s)),
+ Ok(s) => Ok(PathBuf::from(s)),
Err(..) => Err(human("invalid non-unicode path")),
}
}
#[cfg(windows)]
mod imp {
extern crate winapi;
- extern crate "advapi32-sys" as advapi32;
+ extern crate advapi32_sys as advapi32;
use std::io;
use std::ptr;
};
// processing the custom build script
- let new_build = project.build.as_ref().map(PathBuf::new);
+ let new_build = project.build.as_ref().map(PathBuf::from);
// Get targets
let targets = normalize(&lib,
}
None => {
details.path.as_ref().map(|path| {
- cx.nested_paths.push(PathBuf::new(path));
+ cx.nested_paths.push(PathBuf::from(path));
cx.source_id.clone()
})
}
let dep = try!(Dependency::parse(&n,
details.version.as_ref()
- .map(|v| v.as_slice()),
+ .map(|v| &v[..]),
&new_source_id));
let dep = f(dep)
.set_features(details.features.unwrap_or(Vec::new()))
impl PathValue {
fn to_path(&self) -> PathBuf {
match *self {
- PathValue::String(ref s) => PathBuf::new(s),
+ PathValue::String(ref s) => PathBuf::from(s),
PathValue::Path(ref p) => p.clone(),
}
}
extern crate curl;
-extern crate "rustc-serialize" as rustc_serialize;
+extern crate rustc_serialize;
use std::collections::HashMap;
use std::fmt;
+2015-03-26
+ linux-i386 d8b59fb0a0e8222b1753370f1d7c91dcb9697b37
+ linux-x86_64 e2f8388d6bccad3b3f09bbbe4ea1bc9671224f4c
+ macos-i386 3baad9c920c4a68bfd8c10ba3afb80013559adf5
+ macos-x86_64 394afa61b945717bca18412c3c93a428db7d6d5d
+ winnt-i386 4bc98dabc039c34c040942f0eadd99ddb37f06dc
+ winnt-x86_64 54d948ed95b86b9c63861246cf7cfd7161a48a20
+
2015-03-17
linux-i386 96a64fa9b4b6cc0cddaa90ecde4e08254c9025d5
linux-x86_64 354bb5b11b1f19e270ebc0553db1ddc560999bdb
pub fn file(self, path: &str, contents: &str) -> RepoBuilder {
let mut me = self.nocommit_file(path, contents);
- me.files.push(PathBuf::new(path));
+ me.files.push(PathBuf::from(path));
me
}
use std::io::prelude::*;
use std::path::{Path, PathBuf};
use std::process::Output;
-use std::str::{self, Str};
+use std::str;
use url::Url;
use hamcrest as ham;
self.cargo(cmd)
}
- pub fn file<B: AsOsStr + ?Sized>(mut self, path: &B,
- body: &str) -> ProjectBuilder {
+ pub fn file<B: AsRef<Path>>(mut self, path: B,
+ body: &str) -> ProjectBuilder {
self.files.push(FileBuilder::new(self.root.join(path), body));
self
}
- pub fn symlink<T: AsOsStr + ?Sized>(mut self, dst: &T,
- src: &T) -> ProjectBuilder {
+ pub fn symlink<T: AsRef<Path>>(mut self, dst: T,
+ src: T) -> ProjectBuilder {
self.symlinks.push(SymlinkBuilder::new(self.root.join(dst),
self.root.join(src)));
self
path.display()))
}
-pub fn main_file<T: Str>(println: T, deps: &[&str]) -> String {
+pub fn main_file(println: &str, deps: &[&str]) -> String {
let mut buf = String::new();
for dep in deps.iter() {
- buf.push_str(format!("extern crate {};\n", dep).as_slice());
+ buf.push_str(&format!("extern crate {};\n", dep));
}
buf.push_str("fn main() { println!(");
- buf.push_str(println.as_slice());
+ buf.push_str(&println);
buf.push_str("); }\n");
buf.to_string()
// Path to cargo executables
pub fn cargo_dir() -> PathBuf {
- env::var_os("CARGO_BIN_PATH").map(|s| PathBuf::new(&s)).or_else(|| {
+ env::var_os("CARGO_BIN_PATH").map(PathBuf::from).or_else(|| {
env::current_exe().ok().as_ref().and_then(|s| s.parent())
.map(|s| s.to_path_buf())
}).unwrap_or_else(|| {
fn match_std(&self, expected: Option<&String>, actual: &[u8],
description: &str, extra: &[u8]) -> ham::MatchResult {
- match expected.map(|s| Str::as_slice(s)) {
+ match expected.map(|s| &s[..]) {
None => ham::success(),
Some(out) => {
let actual = match str::from_utf8(actual) {
let actual = actual.replace("\r", "");
let actual = actual.replace("\t", "<tab>");
- let a = actual.as_slice().lines();
+ let a = actual.lines();
let e = out.lines();
let diffs = zip_all(a, e).enumerate();
let diffs = diffs.filter_map(|(i, (a,e))| {
match (a, e) {
(Some(a), Some(e)) => {
- if lines_match(e.as_slice(), a.as_slice()) {
+ if lines_match(&e, &a) {
None
} else {
Some(format!("{:3} - |{}|\n + |{}|\n", i, e, a))
Err(e) => {
let mut s = format!("could not exec process {}: {}", process, e);
match e.cause() {
- Some(cause) => s.push_str(format!("\ncaused by: {}",
- cause.description()).as_slice()),
+ Some(cause) => s.push_str(&format!("\ncaused by: {}",
+ cause.description())),
None => {}
}
Err(s)
use flate2::Compression::Default;
use flate2::write::GzEncoder;
use git2;
-use serialize::hex::ToHex;
+use rustc_serialize::hex::ToHex;
use tar::Archive;
use url::Url;
// Init a new registry
repo(®istry_path())
- .file("config.json", format!(r#"
+ .file("config.json", &format!(r#"
{{"dl":"{}","api":""}}
- "#, dl_url()).as_slice())
+ "#, dl_url()))
.build();
}
authors = []
"#, name, version);
for &(dep, req, kind) in deps.iter() {
- manifest.push_str(format!(r#"
+ manifest.push_str(&format!(r#"
[{}dependencies.{}]
version = "{}"
"#, match kind {
"build" => "build-",
"dev" => "dev-",
_ => ""
- }, dep, req).as_slice());
+ }, dep, req));
}
let p = project(name)
- .file("Cargo.toml", manifest.as_slice())
+ .file("Cargo.toml", &manifest)
.file("src/lib.rs", "");
p.build();
fs::create_dir_all(dst.parent().unwrap()).unwrap();
let f = File::create(&dst).unwrap();
let a = Archive::new(GzEncoder::new(f, Default));
- a.append(format!("{}-{}/Cargo.toml", name, version).as_slice(),
+ a.append(&format!("{}-{}/Cargo.toml", name, version),
&mut File::open(&p.root().join("Cargo.toml")).unwrap()).unwrap();
- a.append(format!("{}-{}/src/lib.rs", name, version).as_slice(),
+ a.append(&format!("{}-{}/src/lib.rs", name, version),
&mut File::open(&p.root().join("src/lib.rs")).unwrap()).unwrap();
a.finish().unwrap();
}
3 => format!("3/{}/{}", &name[..1], name),
_ => format!("{}/{}/{}", &name[0..2], &name[2..4], name),
};
- publish(file.as_slice(), line.as_slice());
+ publish(&file, &line);
}
pub fn publish(file: &str, line: &str) {
test!(cargo_bench_simple {
let p = project("foo")
- .file("Cargo.toml", &basic_bin_manifest("foo").as_slice())
+ .file("Cargo.toml", &basic_bin_manifest("foo"))
.file("src/foo.rs", r#"
+ #![feature(test)]
extern crate test;
fn hello() -> &'static str {
execs().with_stdout("hello\n"));
assert_that(p.cargo("bench"),
- execs().with_stdout(format!("\
+ execs().with_stdout(&format!("\
{} foo v0.5.0 ({})
{} target[..]release[..]foo-[..]
authors = []
"#)
.file("benches/bin1.rs", r#"
+ #![feature(test)]
extern crate test;
#[bench] fn run1(_ben: &mut test::Bencher) { }"#)
.file("benches/bin2.rs", r#"
+ #![feature(test)]
extern crate test;
#[bench] fn run2(_ben: &mut test::Bencher) { }"#);
dir = prj.url());
assert_that(prj.cargo_process("bench").arg("--bench").arg("bin2"),
- execs().with_status(0).with_stdout(expected_stdout.as_slice()));
+ execs().with_status(0).with_stdout(expected_stdout));
});
test!(cargo_bench_verbose {
let p = project("foo")
- .file("Cargo.toml", basic_bin_manifest("foo").as_slice())
+ .file("Cargo.toml", &basic_bin_manifest("foo"))
.file("src/foo.rs", r#"
+ #![feature(test)]
extern crate test;
fn main() {}
#[bench] fn bench_hello(_b: &mut test::Bencher) {}
"#);
assert_that(p.cargo_process("bench").arg("-v").arg("hello"),
- execs().with_stdout(format!("\
+ execs().with_stdout(&format!("\
{compiling} foo v0.5.0 ({url})
{running} `rustc src[..]foo.rs [..]`
{running} `[..]target[..]release[..]foo-[..] hello --bench`
authors = []
"#)
.file("src/lib.rs", "
+ #![feature(test)]
extern crate test;
pub fn foo() {}
#[bench] fn lib_bench(_b: &mut test::Bencher) {}
")
.file("src/main.rs", "
+ #![feature(test)]
extern crate foo;
extern crate test;
fn main() {}
#[bench] fn bin_bench(_b: &mut test::Bencher) { foo::foo() }
")
.file("benches/foo.rs", r#"
+ #![feature(test)]
extern crate foo;
extern crate test;
#[bench] fn bench_bench(_b: &mut test::Bencher) { foo::foo() }
test!(cargo_bench_failing_test {
let p = project("foo")
- .file("Cargo.toml", basic_bin_manifest("foo").as_slice())
+ .file("Cargo.toml", &basic_bin_manifest("foo"))
.file("src/foo.rs", r#"
#![feature(test)]
extern crate test;
execs().with_stdout("hello\n"));
assert_that(p.cargo("bench"),
- execs().with_stdout(format!("\
+ execs().with_stdout(&format!("\
{} foo v0.5.0 ({})
{} target[..]release[..]foo-[..]
path = "src/main.rs"
"#)
.file("src/lib.rs", r#"
+ #![feature(test)]
extern crate test;
///
/// ```rust
#[bench] fn lib_bench(_b: &mut test::Bencher) {}
"#)
.file("src/main.rs", "
+ #![feature(test)]
extern crate foo;
extern crate test;
");
assert_that(p.cargo_process("bench"),
- execs().with_stdout(format!("\
+ execs().with_stdout(&format!("\
{} foo v0.0.1 ({})
{running} target[..]release[..]baz-[..]
path = "../foo"
"#)
.file("src/lib.rs", "
+ #![feature(test)]
extern crate foo;
extern crate test;
#[bench]
authors = []
"#)
.file("src/lib.rs", "
+ #![feature(test)]
extern crate test;
pub fn foo() {}
p2.build();
assert_that(p.cargo_process("bench"),
execs().with_status(0)
- .with_stdout(format!("\
+ .with_stdout(&format!("\
{compiling} foo v0.0.1 ({dir})
{compiling} bar v0.0.1 ({dir})
{running} target[..]
",
compiling = COMPILING, running = RUNNING,
- dir = p.url()).as_slice()));
+ dir = p.url())));
});
test!(external_bench_explicit {
path = "src/bench.rs"
"#)
.file("src/lib.rs", r#"
+ #![feature(test)]
extern crate test;
pub fn get_hello() -> &'static str { "Hello" }
fn internal_bench(_b: &mut test::Bencher) {}
"#)
.file("src/bench.rs", r#"
+ #![feature(test)]
extern crate foo;
extern crate test;
"#);
assert_that(p.cargo_process("bench"),
- execs().with_stdout(format!("\
+ execs().with_stdout(&format!("\
{} foo v0.0.1 ({})
{running} target[..]release[..]bench-[..]
authors = []
"#)
.file("src/lib.rs", r#"
+ #![feature(test)]
extern crate test;
pub fn get_hello() -> &'static str { "Hello" }
fn internal_bench(_b: &mut test::Bencher) {}
"#)
.file("benches/external.rs", r#"
+ #![feature(test)]
extern crate foo;
extern crate test;
"#);
assert_that(p.cargo_process("bench"),
- execs().with_stdout(format!("\
+ execs().with_stdout(&format!("\
{} foo v0.0.1 ({})
{running} target[..]release[..]external-[..]
authors = []
"#)
.file("src/lib.rs", "
+ #![feature(test)]
extern crate test;
#[bench] fn foo(_b: &mut test::Bencher) {}
assert_that(p.cargo_process("bench").arg("bar"),
execs().with_status(0)
- .with_stdout(format!("\
+ .with_stdout(&format!("\
{compiling} foo v0.0.1 ({dir})
{running} target[..]release[..]foo-[..]
",
compiling = COMPILING, running = RUNNING,
- dir = p.url()).as_slice()));
+ dir = p.url())));
assert_that(p.cargo("bench").arg("foo"),
execs().with_status(0)
// tests in an rlib
test!(cargo_bench_twice {
let p = project("test_twice")
- .file("Cargo.toml", basic_lib_manifest("test_twice").as_slice())
+ .file("Cargo.toml", &basic_lib_manifest("test_twice"))
.file("src/test_twice.rs", r#"
#![crate_type = "rlib"]
+ #![feature(test)]
extern crate test;
name = "foo"
"#)
.file("src/lib.rs", "
+ #![feature(test)]
extern crate test;
#[bench] fn lib_bench(_b: &mut test::Bencher) {}
")
.file("src/main.rs", "
+ #![feature(test)]
extern crate foo;
extern crate test;
");
assert_that(p.cargo_process("bench"),
- execs().with_stdout(format!("\
+ execs().with_stdout(&format!("\
{} foo v0.0.1 ({})
{running} target[..]release[..]foo-[..]
authors = []
"#)
.file("src/lib.rs", "
+ #![feature(test)]
extern crate test;
/// ```
fn foo_bench(_b: &mut test::Bencher) {}
")
.file("benches/bench.rs", "
+ #![feature(test)]
extern crate syntax;
extern crate test;
assert_that(p.cargo_process("bench"),
execs().with_status(0)
- .with_stdout(format!("\
+ .with_stdout(&format!("\
{compiling} syntax v0.0.1 ({dir})
{running} target[..]release[..]bench-[..]
",
compiling = COMPILING, running = RUNNING,
- dir = p.url()).as_slice()));
+ dir = p.url())));
});
test!(lib_with_standard_name2 {
pub fn foo() {}
")
.file("src/main.rs", "
+ #![feature(test)]
extern crate syntax;
extern crate test;
assert_that(p.cargo_process("bench"),
execs().with_status(0)
- .with_stdout(format!("\
+ .with_stdout(&format!("\
{compiling} syntax v0.0.1 ({dir})
{running} target[..]release[..]syntax-[..]
",
compiling = COMPILING, running = RUNNING,
- dir = p.url()).as_slice()));
+ dir = p.url())));
});
test!(bin_there_for_integration {
authors = []
"#)
.file("src/main.rs", "
+ #![feature(test)]
extern crate test;
- fn main() { std::os::set_exit_status(1); }
+ fn main() { panic!(); }
#[bench] fn main_bench(_b: &mut test::Bencher) {}
")
.file("benches/foo.rs", r#"
+ #![feature(test)]
extern crate test;
- use std::old_io::Command;
+ use std::process::Command;
#[bench]
fn bench_bench(_b: &mut test::Bencher) {
let status = Command::new("target/release/foo").status().unwrap();
- assert!(status.matches_exit_status(1));
+ assert_eq!(status.code(), Some(101));
}
"#);
path = "bar"
"#)
.file("src/lib.rs", r#"
+ #![feature(test)]
extern crate "bar" as the_bar;
extern crate test;
fn foo(_b: &mut test::Bencher) {}
"#)
.file("benches/bench.rs", r#"
+ #![feature(test)]
extern crate "foo" as the_foo;
extern crate test;
assert_that(p.cargo_process("bench").arg("-v"),
execs().with_status(0)
- .with_stdout(format!("\
+ .with_stdout(&format!("\
{compiling} bar v0.0.1 ({dir})
{running} [..] -C opt-level=3 [..]
{compiling} foo v0.0.1 ({dir})
",
compiling = COMPILING, running = RUNNING,
- dir = p.url()).as_slice()));
+ dir = p.url())));
p.root().move_into_the_past().unwrap();
assert_that(p.cargo("bench").arg("-v"),
execs().with_status(0)
- .with_stdout(format!("\
+ .with_stdout(&format!("\
{fresh} bar v0.0.1 ({dir})
{fresh} foo v0.0.1 ({dir})
{running} [..]target[..]release[..]bench-[..]
",
fresh = FRESH, running = RUNNING,
- dir = p.url()).as_slice()));
+ dir = p.url())));
});
test!(bench_twice_with_build_cmd {
"#)
.file("build.rs", "fn main() {}")
.file("src/lib.rs", "
+ #![feature(test)]
extern crate test;
#[bench]
fn foo(_b: &mut test::Bencher) {}
assert_that(p.cargo_process("bench"),
execs().with_status(0)
- .with_stdout(format!("\
+ .with_stdout(&format!("\
{compiling} foo v0.0.1 ({dir})
{running} target[..]release[..]foo-[..]
",
compiling = COMPILING, running = RUNNING,
- dir = p.url()).as_slice()));
+ dir = p.url())));
assert_that(p.cargo("bench"),
execs().with_status(0)
- .with_stdout(format!("\
+ .with_stdout(&format!("\
{running} target[..]release[..]foo-[..]
running 1 test
name = "testb1"
"#)
.file("src/lib.rs", r#"
+ #![feature(test)]
extern crate test;
use test::Bencher;
}
"#)
.file("benches/testb1.rs", "
+ #![feature(test)]
extern crate testbench;
extern crate test;
assert_that(p.cargo_process("bench").arg("-v"),
execs().with_status(0)
- .with_stdout(format!("\
+ .with_stdout(&format!("\
{compiling} testbench v6.6.6 ({url})
{running} `rustc src[..]lib.rs --crate-name testbench --crate-type lib [..]`
{running} `rustc src[..]lib.rs --crate-name testbench --crate-type lib [..]`
compiling = COMPILING,
running = RUNNING,
dir = p.root().display(),
- url = p.url()).as_slice()));
+ url = p.url())));
});
test!(test_a_bench {
assert_that(p.cargo_process("test"),
execs().with_status(0)
- .with_stdout(format!("\
+ .with_stdout(&format!("\
{compiling} foo v0.1.0 ([..])
{running} target[..]debug[..]b-[..]
let valid = ["GET", "Authorization", "Accept", "User-Agent"];
rdr.lines().map(|s| s.unwrap())
.take_while(|s| s.len() > 2)
- .map(|s| s.as_slice().trim().to_string())
+ .map(|s| s.trim().to_string())
.filter(|s| {
- valid.iter().any(|prefix| s.as_slice().starts_with(*prefix))
+ valid.iter().any(|prefix| s.starts_with(*prefix))
})
.collect()
}
let config = paths::home().join(".gitconfig");
let mut config = git2::Config::open(&config).unwrap();
config.set_str("credential.helper",
- script.display().to_string().as_slice()).unwrap();
+ &script.display().to_string()).unwrap();
let p = project("foo")
.file("Cargo.toml", &format!(r#"
.file("src/main.rs", "");
assert_that(p.cargo_process("build").arg("-v"),
- execs().with_status(101).with_stdout(format!("\
+ execs().with_status(101).with_stdout(&format!("\
{updating} git repository `http://{addr}/foo/bar`
",
updating = UPDATING,
addr = addr,
- ).as_slice())
- .with_stderr(format!("\
+ ))
+ .with_stderr(&format!("\
Unable to update http://{addr}/foo/bar
Caused by:
.file("src/main.rs", "");
assert_that(p.cargo_process("build").arg("-v"),
- execs().with_status(101).with_stdout(format!("\
+ execs().with_status(101).with_stdout(&format!("\
{updating} git repository `https://{addr}/foo/bar`
",
updating = UPDATING,
addr = addr,
- ).as_slice())
- .with_stderr(format!("\
+ ))
+ .with_stderr(&format!("\
Unable to update https://{addr}/foo/bar
Caused by:
});
let p = project("foo")
- .file("Cargo.toml", format!(r#"
+ .file("Cargo.toml", &format!(r#"
[project]
name = "foo"
version = "0.0.1"
[dependencies.bar]
git = "ssh://127.0.0.1:{}/foo/bar"
- "#, addr.port()).as_slice())
+ "#, addr.port()))
.file("src/main.rs", "");
assert_that(p.cargo_process("build").arg("-v"),
- execs().with_status(101).with_stdout(format!("\
+ execs().with_status(101).with_stdout(&format!("\
{updating} git repository `ssh://{addr}/foo/bar`
",
updating = UPDATING,
addr = addr,
- ).as_slice())
- .with_stderr(format!("\
+ ))
+ .with_stderr(&format!("\
Unable to update ssh://{addr}/foo/bar
Caused by:
test!(cargo_clean_simple {
let p = project("foo")
- .file("Cargo.toml", &basic_bin_manifest("foo").as_slice())
- .file("src/foo.rs", &main_file(r#""i am foo""#, &[]).as_slice());
+ .file("Cargo.toml", &basic_bin_manifest("foo"))
+ .file("src/foo.rs", &main_file(r#""i am foo""#, &[]));
assert_that(p.cargo_process("build"), execs().with_status(0));
assert_that(&p.build_dir(), existing_dir());
test!(different_dir {
let p = project("foo")
- .file("Cargo.toml", &basic_bin_manifest("foo").as_slice())
- .file("src/foo.rs", &main_file(r#""i am foo""#, &[]).as_slice())
+ .file("Cargo.toml", &basic_bin_manifest("foo"))
+ .file("src/foo.rs", &main_file(r#""i am foo""#, &[]))
.file("src/bar/a.rs", "");
assert_that(p.cargo_process("build"), execs().with_status(0));
test!(cargo_compile_simple {
let p = project("foo")
- .file("Cargo.toml", &basic_bin_manifest("foo").as_slice())
- .file("src/foo.rs", &main_file(r#""i am foo""#, &[]).as_slice());
+ .file("Cargo.toml", &basic_bin_manifest("foo"))
+ .file("src/foo.rs", &main_file(r#""i am foo""#, &[]));
assert_that(p.cargo_process("build"), execs());
assert_that(&p.bin("foo"), existing_file());
test!(cargo_compile_manifest_path {
let p = project("foo")
- .file("Cargo.toml", &basic_bin_manifest("foo").as_slice())
- .file("src/foo.rs", &main_file(r#""i am foo""#, &[]).as_slice());
+ .file("Cargo.toml", &basic_bin_manifest("foo"))
+ .file("src/foo.rs", &main_file(r#""i am foo""#, &[]));
assert_that(p.cargo_process("build")
.arg("--manifest-path").arg("foo/Cargo.toml")
test!(cargo_compile_with_invalid_code {
let p = project("foo")
- .file("Cargo.toml", basic_bin_manifest("foo").as_slice())
+ .file("Cargo.toml", &basic_bin_manifest("foo"))
.file("src/foo.rs", "invalid rust code!");
assert_that(p.cargo_process("build"),
"#)
.file("src/main.rs", "invalid rust code!");
let bar = project("bar")
- .file("Cargo.toml", basic_bin_manifest("bar").as_slice())
+ .file("Cargo.toml", &basic_bin_manifest("bar"))
.file("src/lib.rs", "invalid rust code!");
let baz = project("baz")
- .file("Cargo.toml", basic_bin_manifest("baz").as_slice())
+ .file("Cargo.toml", &basic_bin_manifest("baz"))
.file("src/lib.rs", "invalid rust code!");
bar.build();
baz.build();
test!(cargo_compile_with_warnings_in_the_root_package {
let p = project("foo")
- .file("Cargo.toml", basic_bin_manifest("foo").as_slice())
+ .file("Cargo.toml", &basic_bin_manifest("foo"))
.file("src/foo.rs", "fn main() {} fn dead() {}");
assert_that(p.cargo_process("build"),
name = "foo"
"#)
.file("src/foo.rs",
- main_file(r#""{}", bar::gimme()"#, &["bar"]).as_slice())
+ &main_file(r#""{}", bar::gimme()"#, &["bar"]))
.file("bar/Cargo.toml", r#"
[project]
assert_that(p.cargo_process("build"),
execs()
- .with_stdout(format!("{} bar v0.5.0 ({})\n\
+ .with_stdout(&format!("{} bar v0.5.0 ({})\n\
{} foo v0.5.0 ({})\n",
COMPILING, p.url(),
COMPILING, p.url()))
name = "foo"
"#)
.file("src/foo.rs",
- main_file(r#""{}", bar::gimme()"#, &["bar"]).as_slice())
+ &main_file(r#""{}", bar::gimme()"#, &["bar"]))
.file("bar/Cargo.toml", r#"
[project]
name = "foo"
"#)
.file("src/main.rs",
- main_file(r#""{}", bar::gimme()"#, &["bar"]).as_slice())
+ &main_file(r#""{}", bar::gimme()"#, &["bar"]))
.file("bar/Cargo.toml", r#"
[project]
name = "foo"
"#)
.file("src/foo.rs",
- main_file(r#""{}", bar::gimme()"#, &["bar"]).as_slice())
+ &main_file(r#""{}", bar::gimme()"#, &["bar"]))
.file("bar/Cargo.toml", r#"
[project]
name = "foo"
"#)
.file("src/foo.rs",
- main_file(r#""{}", bar::gimme()"#, &["bar"]).as_slice())
+ &main_file(r#""{}", bar::gimme()"#, &["bar"]))
.file("bar/Cargo.toml", r#"
[project]
path = "bar"
"#)
- .file("src/foo.rs", main_file(r#""i am foo""#, &["bar"]).as_slice())
- .file("bar/Cargo.toml", basic_bin_manifest("bar").as_slice())
- .file("bar/src/bar.rs", main_file(r#""i am bar""#, &[]).as_slice());
+ .file("src/foo.rs", &main_file(r#""i am foo""#, &["bar"]))
+ .file("bar/Cargo.toml", &basic_bin_manifest("bar"))
+ .file("bar/src/bar.rs", &main_file(r#""i am bar""#, &[]));
assert_that(p.cargo_process("build"),
- execs().with_status(101).with_stderr(format!(
+ execs().with_status(101).with_stderr(&format!(
r#"no matching package named `notquitebar` found (required by `foo`)
location searched: {proj_dir}
version required: *
println!("bin");
assert_that(process(&p.bin("foo")).unwrap(),
- execs().with_stdout(format!("0-5-1 @ alpha.1 in {}\n",
- p.root().display()).as_slice()));
+ execs().with_stdout(&format!("0-5-1 @ alpha.1 in {}\n",
+ p.root().display())));
println!("test");
assert_that(p.cargo("test").arg("-v"),
}
}).collect();
files.sort();
- let file0 = files[0].as_slice();
- let file1 = files[1].as_slice();
+ let file0 = &files[0];
+ let file1 = &files[1];
println!("{} {}", file0, file1);
assert!(file0.ends_with(".rlib") || file1.ends_with(".rlib"));
assert!(file0.ends_with(env::consts::DLL_SUFFIX) ||
}
}).collect();
files.sort();
- let file0 = files[0].as_slice();
- let file1 = files[1].as_slice();
+ let file0 = &files[0];
+ let file1 = &files[1];
println!("{} {}", file0, file1);
assert!(file0.ends_with(".rlib") || file1.ends_with(".rlib"));
assert!(file0.ends_with(env::consts::DLL_SUFFIX) ||
if cfg!(windows) { return }
let p = project("foo")
- .file("Cargo.toml", basic_bin_manifest("foo").as_slice())
- .file("src/foo.rs", main_file(r#""i am foo""#, &[]).as_slice())
+ .file("Cargo.toml", &basic_bin_manifest("foo"))
+ .file("src/foo.rs", &main_file(r#""i am foo""#, &[]))
.symlink("Notafile", "bar");
assert_that(p.cargo_process("build"), execs());
"#)
.file("src/main.rs", "fn main() {}");
assert_that(p.cargo_process("build").arg("-v").arg("--release"),
- execs().with_status(0).with_stdout(format!("\
+ execs().with_status(0).with_stdout(&format!("\
{compiling} test v0.0.0 ({url})
{running} `rustc src[..]main.rs --crate-name test --crate-type bin \
-C opt-level=3 \
"#)
.file("src/lib.rs", "");
assert_that(p.cargo_process("build").arg("-v"),
- execs().with_status(0).with_stdout(format!("\
+ execs().with_status(0).with_stdout(&format!("\
{compiling} test v0.0.0 ({url})
{running} `rustc src[..]lib.rs --crate-name test --crate-type lib -g \
-C metadata=[..] \
"#)
.file("src/lib.rs", "");
assert_that(p.cargo_process("build").arg("-v").arg("--release"),
- execs().with_status(0).with_stdout(format!("\
+ execs().with_status(0).with_stdout(&format!("\
{compiling} test v0.0.0 ({url})
{running} `rustc src[..]lib.rs --crate-name test --crate-type lib \
-C opt-level=3 \
"#)
.file("foo/src/lib.rs", "");
assert_that(p.cargo_process("build").arg("-v").arg("--release"),
- execs().with_status(0).with_stdout(format!("\
+ execs().with_status(0).with_stdout(&format!("\
{compiling} foo v0.0.0 ({url})
{running} `rustc foo[..]src[..]lib.rs --crate-name foo \
--crate-type dylib --crate-type rlib -C prefer-dynamic \
dir = p.root().display(),
url = p.url(),
prefix = env::consts::DLL_PREFIX,
- suffix = env::consts::DLL_SUFFIX).as_slice()));
+ suffix = env::consts::DLL_SUFFIX)));
});
test!(explicit_examples {
assert_that(p.cargo_process("build"),
execs().with_status(0)
- .with_stdout(format!("\
+ .with_stdout(&format!("\
{compiling} syntax v0.0.1 ({dir})
",
compiling = COMPILING,
- dir = p.url()).as_slice()));
+ dir = p.url())));
});
test!(simple_staticlib {
assert_that(foo.cargo("build"),
execs().with_status(0)
- .with_stdout(format!("\
+ .with_stdout(&format!("\
{compiling} foo v0.0.0 ({url})
", compiling = COMPILING, url = foo.url())));
"#)
.file("build.rs", r#"
use std::env;
- use std::old_io::File;
- use std::old_path::{Path, GenericPath};
+ use std::fs::File;
+ use std::path::Path;
fn main() {
- let path = Path::new(env::var("OUT_DIR").unwrap()).join("foo");
+ let path = Path::new(&env::var("OUT_DIR").unwrap()).join("foo");
if env::var_os("FIRST").is_some() {
File::create(&path).unwrap();
} else {
assert_that(foo.cargo("build").env("FIRST", "1"),
execs().with_status(0)
- .with_stdout(format!("\
+ .with_stdout(&format!("\
{compiling} foo v0.0.0 ({url})
", compiling = COMPILING, url = foo.url())));
File::create(&foo.root().join("src/bar.rs")).unwrap();
assert_that(foo.cargo("build"),
execs().with_status(0)
- .with_stdout(format!("\
+ .with_stdout(&format!("\
{compiling} foo v0.0.0 ({url})
", compiling = COMPILING, url = foo.url())));
});
path = "bar"
"#)
.file("src/main.rs",
- main_file(r#""{}", bar::gimme()"#, &["bar"]).as_slice())
+ &main_file(r#""{}", bar::gimme()"#, &["bar"]))
.file("bar/Cargo.toml", r#"
[project]
path = "bar"
"#)
.file("src/main.rs",
- main_file(r#""{}", bar::gimme()"#, &["bar"]).as_slice())
+ &main_file(r#""{}", bar::gimme()"#, &["bar"]))
.file("bar/Cargo.toml", r#"
[project]
"#);
assert_that(p.cargo_process("build").arg("-v"),
execs().with_status(101)
- .with_stdout(format!("\
+ .with_stdout(&format!("\
{compiling} foo v0.5.0 ({url})
{running} `rustc build.rs --crate-name build_script_build --crate-type bin [..]`
{running} `[..]build-script-build[..]`
",
url = p.url(), compiling = COMPILING, running = RUNNING))
- .with_stderr(format!("\
+ .with_stderr(&format!("\
failed to run custom build command for `foo v0.5.0 ({})`
Process didn't exit successfully: `[..]build[..]build-script-build[..]` \
(exit code: 101)",
use std::env;
use std::io::prelude::*;
use std::path::Path;
+ use std::fs;
fn main() {{
let _target = env::var("TARGET").unwrap();
let out = env::var("OUT_DIR").unwrap();
assert!(out.starts_with(r"{0}"));
- assert!(Path::new(&out).is_dir());
+ assert_eq!(fs::metadata(&out).map(|m| m.is_dir()), Ok(true));
let _host = env::var("HOST").unwrap();
assert_that(p.cargo_process("build"),
execs().with_status(101)
- .with_stderr(format!("\
+ .with_stderr(&format!("\
Only `-l` and `-L` flags are allowed in build script of `foo v0.5.0 ({})`: \
`-aaa -bbb`",
p.url())));
// TODO: TEST FAILS BECAUSE OF WRONG STDOUT (but otherwise, the build works)
assert_that(p.cargo_process("build").arg("--verbose"),
execs().with_status(101)
- .with_stdout(format!("\
+ .with_stdout(&format!("\
{compiling} bar v0.5.0 ({url})
{running} `rustc {dir}{sep}src{sep}lib.rs --crate-name test --crate-type lib -g \
-C metadata=[..] \
.file("build.rs", r#"
use std::env;
fn main() {
- assert_eq!(env::var("DEP_FOO_FOO").unwrap().as_slice(), "bar");
- assert_eq!(env::var("DEP_FOO_BAR").unwrap().as_slice(), "baz");
+ assert_eq!(env::var("DEP_FOO_FOO").unwrap(), "bar");
+ assert_eq!(env::var("DEP_FOO_BAR").unwrap(), "baz");
}
"#)
- .file(".cargo/config", format!(r#"
+ .file(".cargo/config", &format!(r#"
[target.{}.foo]
rustc-flags = "-L foo -L bar"
foo = "bar"
bar = "baz"
- "#, target).as_slice())
+ "#, target))
.file("a/Cargo.toml", r#"
[project]
name = "a"
assert_that(p.cargo_process("build").arg("-v"),
execs().with_status(0)
- .with_stdout(format!("\
+ .with_stdout(&format!("\
[..]
[..]
[..]
[..]
[..]
{running} `rustc [..] --crate-name foo [..] -L foo -L bar[..]`
-", running = RUNNING).as_slice()));
+", running = RUNNING)));
});
test!(unused_overrides {
"#)
.file("src/lib.rs", "")
.file("build.rs", "fn main() {}")
- .file(".cargo/config", format!(r#"
+ .file(".cargo/config", &format!(r#"
[target.{}.foo]
rustc-flags = "-L foo -L bar"
foo = "bar"
bar = "baz"
- "#, target).as_slice());
+ "#, target));
assert_that(p.cargo_process("build").arg("-v"),
execs().with_status(0));
.file("build.rs", r#"
use std::env;
fn main() {
- assert_eq!(env::var("DEP_FOO_FOO").unwrap().as_slice(), "bar");
- assert_eq!(env::var("DEP_FOO_BAR").unwrap().as_slice(), "baz");
+ assert_eq!(env::var("DEP_FOO_FOO").unwrap(), "bar");
+ assert_eq!(env::var("DEP_FOO_BAR").unwrap(), "baz");
}
"#)
.file("a/Cargo.toml", r#"
assert_that(p.cargo_process("build").arg("-v"),
execs().with_status(0)
- .with_stdout(format!("\
+ .with_stdout(&format!("\
{compiling} [..] v0.5.0 (file://[..])
{running} `rustc [..]build.rs [..]`
{compiling} [..] v0.5.0 (file://[..])
{running} `[..]`
{running} `[..]`
{running} `rustc [..] --crate-name foo [..]`
-", compiling = COMPILING, running = RUNNING).as_slice()));
+", compiling = COMPILING, running = RUNNING)));
});
test!(only_rerun_build_script {
assert_that(p.cargo("build").arg("-v"),
execs().with_status(0)
- .with_stdout(format!("\
+ .with_stdout(&format!("\
{compiling} foo v0.5.0 (file://[..])
{running} `[..]build-script-build[..]`
{running} `rustc [..] --crate-name foo [..]`
-", compiling = COMPILING, running = RUNNING).as_slice()));
+", compiling = COMPILING, running = RUNNING)));
});
test!(rebuild_continues_to_pass_env_vars {
.file("build.rs", r#"
use std::env;
fn main() {
- assert_eq!(env::var("DEP_FOO_FOO").unwrap().as_slice(), "bar");
- assert_eq!(env::var("DEP_FOO_BAR").unwrap().as_slice(), "baz");
+ assert_eq!(env::var("DEP_FOO_FOO").unwrap(), "bar");
+ assert_eq!(env::var("DEP_FOO_BAR").unwrap(), "baz");
}
"#);
println!("test");
assert_that(p.cargo("test").arg("-vj1"),
execs().with_status(0)
- .with_stdout(format!("\
+ .with_stdout(&format!("\
{compiling} foo v0.5.0 (file://[..])
{running} `[..]build-script-build[..]`
{running} `rustc [..] --crate-name foo [..]`
test result: ok. 0 passed; 0 failed; 0 ignored; 0 measured
-", compiling = COMPILING, running = RUNNING, doctest = DOCTEST).as_slice()));
+", compiling = COMPILING, running = RUNNING, doctest = DOCTEST)));
println!("doc");
assert_that(p.cargo("doc").arg("-v"),
execs().with_status(0)
- .with_stdout(format!("\
+ .with_stdout(&format!("\
{compiling} foo v0.5.0 (file://[..])
{running} `rustdoc [..]`
-", compiling = COMPILING, running = RUNNING).as_slice()));
+", compiling = COMPILING, running = RUNNING)));
File::create(&p.root().join("src/main.rs")).unwrap()
.write_all(b"fn main() {}").unwrap();
println!("run");
assert_that(p.cargo("run"),
execs().with_status(0)
- .with_stdout(format!("\
+ .with_stdout(&format!("\
{compiling} foo v0.5.0 (file://[..])
{running} `target[..]foo[..]`
-", compiling = COMPILING, running = RUNNING).as_slice()));
+", compiling = COMPILING, running = RUNNING)));
});
test!(propagation_of_l_flags {
"#)
.file("b/src/lib.rs", "")
.file("b/build.rs", "bad file")
- .file(".cargo/config", format!(r#"
+ .file(".cargo/config", &format!(r#"
[target.{}.foo]
rustc-flags = "-L foo"
- "#, target).as_slice());
+ "#, target));
assert_that(p.cargo_process("build").arg("-v").arg("-j1"),
execs().with_status(0)
- .with_stdout(format!("\
+ .with_stdout(&format!("\
[..]
[..]
[..]
{running} `rustc [..] --crate-name a [..]-L bar[..]-L foo[..]`
{compiling} foo v0.5.0 (file://[..])
{running} `rustc [..] --crate-name foo [..] -L bar -L foo`
-", compiling = COMPILING, running = RUNNING).as_slice()));
+", compiling = COMPILING, running = RUNNING)));
});
test!(propagation_of_l_flags_new {
"#)
.file("b/src/lib.rs", "")
.file("b/build.rs", "bad file")
- .file(".cargo/config", format!(r#"
+ .file(".cargo/config", &format!(r#"
[target.{}.foo]
rustc-link-search = ["foo"]
- "#, target).as_slice());
+ "#, target));
assert_that(p.cargo_process("build").arg("-v").arg("-j1"),
execs().with_status(0)
- .with_stdout(format!("\
+ .with_stdout(&format!("\
[..]
[..]
[..]
{running} `rustc [..] --crate-name a [..]-L bar[..]-L foo[..]`
{compiling} foo v0.5.0 (file://[..])
{running} `rustc [..] --crate-name foo [..] -L bar -L foo`
-", compiling = COMPILING, running = RUNNING).as_slice()));
+", compiling = COMPILING, running = RUNNING)));
});
test!(build_deps_simple {
assert_that(p.cargo_process("build").arg("-v"),
execs().with_status(0)
- .with_stdout(format!("\
+ .with_stdout(&format!("\
{compiling} a v0.5.0 (file://[..])
{running} `rustc [..] --crate-name a [..]`
{compiling} foo v0.5.0 (file://[..])
{running} `rustc build.rs [..] --extern a=[..]`
{running} `[..]foo-[..]build-script-build[..]`
{running} `rustc [..] --crate-name foo [..]`
-", compiling = COMPILING, running = RUNNING).as_slice()));
+", compiling = COMPILING, running = RUNNING)));
});
test!(build_deps_not_for_normal {
assert_that(p.cargo_process("build").arg("-v"),
execs().with_status(0)
- .with_stdout(format!("\
+ .with_stdout(&format!("\
{compiling} b v0.5.0 (file://[..])
{running} `rustc [..] --crate-name b [..]`
{compiling} a v0.5.0 (file://[..])
-C metadata=[..] -C extra-filename=-[..] \
--out-dir [..]target[..]debug --emit=dep-info,link \
-L [..]target[..]debug -L [..]target[..]deps`
-", compiling = COMPILING, running = RUNNING).as_slice()));
+", compiling = COMPILING, running = RUNNING)));
});
test!(out_dir_is_preserved {
.file("src/lib.rs", "")
.file("build.rs", r#"
use std::env;
- use std::old_io::File;
- use std::old_path::{Path, GenericPath};
+ use std::fs::File;
+ use std::path::Path;
fn main() {
let out = env::var("OUT_DIR").unwrap();
- File::create(&Path::new(out).join("foo")).unwrap();
+ File::create(Path::new(&out).join("foo")).unwrap();
}
"#);
use std::old_io::File;
fn main() {
let out = env::var("OUT_DIR").unwrap();
- File::open(&Path::new(out).join("foo")).unwrap();
+ File::open(&Path::new(&out).join("foo")).unwrap();
}
"#).unwrap();
p.root().move_into_the_past().unwrap();
"#);
assert_that(p.cargo_process("build").arg("-v"),
execs().with_status(101)
- .with_stdout(format!("\
+ .with_stdout(&format!("\
{compiling} foo v0.5.0 (file://[..])
{running} `rustc build.rs [..]`
{running} `[..]foo-[..]build-script-build[..]`
{running} `rustc [..] --crate-name foo [..] -L foo -l foo:static`
-", compiling = COMPILING, running = RUNNING).as_slice()));
+", compiling = COMPILING, running = RUNNING)));
});
test!(output_separate_lines_new {
"#);
assert_that(p.cargo_process("build").arg("-v"),
execs().with_status(101)
- .with_stdout(format!("\
+ .with_stdout(&format!("\
{compiling} foo v0.5.0 (file://[..])
{running} `rustc build.rs [..]`
{running} `[..]foo-[..]build-script-build[..]`
{running} `rustc [..] --crate-name foo [..] -L foo -l static=foo`
-", compiling = COMPILING, running = RUNNING).as_slice()));
+", compiling = COMPILING, running = RUNNING)));
});
#[cfg(not(windows))] // FIXME(#867)
}
"#)
.file("build.rs", r#"
+ #![feature(convert)]
use std::env;
- use std::old_io::{File, Writer};
- use std::old_path::{Path, GenericPath};
+ use std::fs::File;
+ use std::io::prelude::*;
+ use std::path::PathBuf;
fn main() {
- let dst = Path::new(env::var("OUT_DIR").unwrap());
+ let dst = PathBuf::from(env::var("OUT_DIR").unwrap());
let mut f = File::create(&dst.join("hello.rs")).unwrap();
- f.write_str("
+ f.write_all(b"
pub fn message() -> &'static str {
\"Hello, World!\"
}
"#);
assert_that(p.cargo_process("run"),
execs().with_status(0)
- .with_stdout(format!("\
+ .with_stdout(&format!("\
{compiling} foo v0.5.0 (file://[..])
{running} `target[..]foo`
Hello, World!
-", compiling = COMPILING, running = RUNNING).as_slice()));
+", compiling = COMPILING, running = RUNNING)));
assert_that(p.cargo_process("test"),
execs().with_status(0));
}
"#)
.file("build.rs", r#"
+ #![feature(convert)]
use std::env;
- use std::old_io::{File, Writer};
- use std::old_path::{Path, GenericPath};
+ use std::io::prelude::*;
+ use std::fs::File;
+ use std::path::PathBuf;
fn main() {
- let out = Path::new(env::var("OUT_DIR").unwrap());
- File::create(&out.join("foo.rs")).write_str("
+ let out = PathBuf::from(env::var("OUT_DIR").unwrap());
+ File::create(out.join("foo.rs")).unwrap().write_all(b"
fn foo() -> i32 { 1 }
").unwrap();
}
build = "build.rs"
"#)
.file("bar/build.rs", r#"
+ #![feature(convert)]
use std::env;
- use std::old_path::{Path, GenericPath};
+ use std::path::PathBuf;
fn main() {
- let src = Path::new(env::var("SRC").unwrap());
- println!("cargo:rustc-flags=-L {}", src.dir_path().display());
+ let src = PathBuf::from(env::var("SRC").unwrap());
+ println!("cargo:rustc-flags=-L {}", src.parent().unwrap()
+ .display());
}
"#)
.file("bar/src/lib.rs", &format!(r#"
assert_that(project.cargo_process("build"),
execs()
- .with_stdout(format!("{} git repository `{}`\n\
+ .with_stdout(&format!("{} git repository `{}`\n\
{} dep1 v0.5.0 ({}#[..])\n\
{} foo v0.5.0 ({})\n",
UPDATING, path2url(git_root.clone()),
assert_that(project.cargo_process("build"),
execs()
- .with_stdout(format!("{} git repository `{}`\n\
+ .with_stdout(&format!("{} git repository `{}`\n\
{} dep1 v0.5.0 ({}?branch=branchy#[..])\n\
{} foo v0.5.0 ({})\n",
UPDATING, path2url(git_root.clone()),
assert_that(project.cargo_process("build"),
execs()
- .with_stdout(format!("{} git repository `{}`\n\
+ .with_stdout(&format!("{} git repository `{}`\n\
{} dep1 v0.5.0 ({}?tag=v0.1.0#[..])\n\
{} foo v0.5.0 ({})\n",
UPDATING, path2url(git_root.clone()),
name = "parent"
"#, git_project.url()))
.file("src/parent.rs",
- main_file(r#""{}", dep1::hello()"#, &["dep1"]).as_slice());
+ &main_file(r#""{}", dep1::hello()"#, &["dep1"]));
p.cargo_process("build")
.exec_with_output()
name = "parent"
"#, git_project.url(), git_project.url()))
.file("src/parent.rs",
- main_file(r#""{} {}", dep1::hello(), dep2::hello()"#, &["dep1", "dep2"]).as_slice());
+ &main_file(r#""{} {}", dep1::hello(), dep2::hello()"#, &["dep1", "dep2"]));
p.cargo_process("build")
.exec_with_output()
assert_that(project.cargo_process("build"),
execs()
.with_stdout("")
- .with_stderr(format!("\
+ .with_stderr(&format!("\
failed to parse manifest at `[..]`
Caused by:
[dependencies.baz]
path = "../baz"
- "#, bar.url(), rev1).as_slice())
+ "#, bar.url(), rev1))
.file("src/main.rs", r#"
extern crate bar;
extern crate baz;
[dependencies.bar]
git = '{}'
rev = "{}"
- "#, bar.url(), rev2).as_slice())
+ "#, bar.url(), rev2))
.file("src/lib.rs", r#"
extern crate bar;
pub fn baz() -> i32 { bar::bar() }
name = "foo"
"#, git_project.url()))
.file("src/foo.rs",
- main_file(r#""{:?}", bar::bar()"#, &["bar"]).as_slice());
+ &main_file(r#""{:?}", bar::bar()"#, &["bar"]));
// First time around we should compile both foo and bar
assert_that(p.cargo_process("build"),
- execs().with_stdout(format!("{} git repository `{}`\n\
+ execs().with_stdout(&format!("{} git repository `{}`\n\
{} bar v0.5.0 ({}#[..])\n\
{} foo v0.5.0 ({})\n",
UPDATING, git_project.url(),
execs().with_stdout(""));
assert_that(p.cargo("update"),
- execs().with_stdout(format!("{} git repository `{}`",
+ execs().with_stdout(&format!("{} git repository `{}`",
UPDATING,
git_project.url())));
// Update the dependency and carry on!
assert_that(p.cargo("update"),
- execs().with_stdout(format!("{} git repository `{}`",
+ execs().with_stdout(&format!("{} git repository `{}`",
UPDATING,
git_project.url())));
println!("going for the last compile");
assert_that(p.cargo("build"),
- execs().with_stdout(format!("{} bar v0.5.0 ({}#[..])\n\
+ execs().with_stdout(&format!("{} bar v0.5.0 ({}#[..])\n\
{} foo v0.5.0 ({})\n",
COMPILING, git_project.url(),
COMPILING, p.url())));
.arg("-p").arg("foo"),
execs().with_stdout(""));
assert_that(p.cargo("build"),
- execs().with_stdout(format!("{} foo v0.5.0 ({})\n",
+ execs().with_stdout(&format!("{} foo v0.5.0 ({})\n",
COMPILING, p.url())));
});
// First time around we should compile both foo and bar
assert_that(p.cargo_process("build"),
- execs().with_stdout(format!("\
+ execs().with_stdout(&format!("\
{updating} git repository `{git}`
{compiling} bar v0.5.0 ({git}#[..])
{compiling} [..] v0.5.0 ({dir})
assert_that(p.cargo("update")
.arg("-p").arg("dep1")
.arg("--aggressive"),
- execs().with_stdout(format!("{} git repository `{}`",
+ execs().with_stdout(&format!("{} git repository `{}`",
UPDATING,
git_project.url())));
// Make sure we still only compile one version of the git repo
println!("build");
assert_that(p.cargo("build"),
- execs().with_stdout(format!("\
+ execs().with_stdout(&format!("\
{compiling} bar v0.5.0 ({git}#[..])
{compiling} [..] v0.5.0 ({dir})
{compiling} [..] v0.5.0 ({dir})
// We should be able to update transitive deps
assert_that(p.cargo("update").arg("-p").arg("bar"),
- execs().with_stdout(format!("{} git repository `{}`",
+ execs().with_stdout(&format!("{} git repository `{}`",
UPDATING,
git_project.url())));
});
assert_that(project.cargo_process("build"),
execs()
- .with_stdout(format!("{} git repository `[..]`\n\
+ .with_stdout(&format!("{} git repository `[..]`\n\
{} git repository `[..]`\n\
{} [..] v0.5.0 ([..])\n\
{} [..] v0.5.0 ([..])\n\
assert_that(project.cargo("update")
.arg("-p").arg("dep1"),
execs()
- .with_stdout(format!("{} git repository `{}`\n",
+ .with_stdout(&format!("{} git repository `{}`\n",
UPDATING, git1.url()))
.with_stderr(""));
});
// Now build!
assert_that(foo.cargo("build"),
execs().with_status(0)
- .with_stdout(format!("\
+ .with_stdout(&format!("\
{updating} git repository `{bar}`
{compiling} bar v0.0.0 ({bar}#[..])
{compiling} foo v0.0.0 ({foo})
}).unwrap();
let repo = git2::Repository::open(&git_project.root()).unwrap();
- let mut sub = add_submodule(&repo, git_project2.url().to_string().as_slice(),
+ let mut sub = add_submodule(&repo, &git_project2.url().to_string(),
&Path::new("src"));
commit(&repo);
println!("first run");
assert_that(project.cargo_process("run"), execs()
- .with_stdout(format!("{} git repository `[..]`\n\
+ .with_stdout(&format!("{} git repository `[..]`\n\
{} dep1 v0.5.0 ([..])\n\
{} foo v0.5.0 ([..])\n\
{} `target[..]foo[..]`\n\
{
let subrepo = sub.open().unwrap();
let mut origin = subrepo.find_remote("origin").unwrap();
- origin.set_url(git_project3.url().to_string().as_slice()).unwrap();
+ origin.set_url(&git_project3.url().to_string()).unwrap();
origin.add_fetch("refs/heads/*:refs/heads/*").unwrap();;
origin.fetch(&[], None).unwrap();
origin.save().unwrap();
assert_that(project.cargo("update").arg("-v"),
execs()
.with_stderr("")
- .with_stdout(format!("{} git repository `{}`",
+ .with_stdout(&format!("{} git repository `{}`",
UPDATING,
git_project.url())));
println!("last run");
assert_that(project.cargo("run"), execs()
- .with_stdout(format!("{compiling} dep1 v0.5.0 ([..])\n\
+ .with_stdout(&format!("{compiling} dep1 v0.5.0 ([..])\n\
{compiling} foo v0.5.0 ([..])\n\
{running} `target[..]foo[..]`\n\
project3\
[dev-dependencies.bar]
version = "0.5.0"
git = '{}'
- "#, p2.url()).as_slice())
+ "#, p2.url()))
.file("src/main.rs", r#"
fn main() {}
// Generate a lockfile which did not use `bar` to compile, but had to update
// `bar` to generate the lockfile
assert_that(p.cargo_process("build"),
- execs().with_stdout(format!("\
+ execs().with_stdout(&format!("\
{updating} git repository `{bar}`
{compiling} foo v0.5.0 ({url})
", updating = UPDATING, compiling = COMPILING, url = p.url(), bar = p2.url())));
// Make sure we use the previous resolution of `bar` instead of updating it
// a second time.
assert_that(p.cargo("test"),
- execs().with_stdout(format!("\
+ execs().with_stdout(&format!("\
{compiling} [..] v0.5.0 ([..])
{compiling} [..] v0.5.0 ([..]
{running} target[..]foo-[..]
assert_that(foo.cargo("build"),
execs().with_status(0)
- .with_stdout(format!("\
+ .with_stdout(&format!("\
{compiling} foo v0.0.0 ({url})
", compiling = COMPILING, url = foo.url())));
[dev-dependencies.bar]
git = '{}'
- "#, p2.url()).as_slice())
+ "#, p2.url()))
.file("src/main.rs", "fn main() {}");
// Generate a lockfile which did not use `bar` to compile, but had to update
// `bar` to generate the lockfile
assert_that(p.cargo_process("build"),
- execs().with_stdout(format!("\
+ execs().with_stdout(&format!("\
{updating} git repository `{bar}`
{compiling} foo v0.5.0 ({url})
", updating = UPDATING, compiling = COMPILING, url = p.url(), bar = p2.url())));
build = 'build.rs'
[dependencies.bar]
git = '{}'
- "#, bar.url()).as_slice())
+ "#, bar.url()))
.file("src/main.rs", "fn main() {}")
.file("build.rs", "fn main() {}");
p1.build();
p1.root().move_into_the_past().unwrap();
assert_that(p1.cargo("build"),
- execs().with_stdout(format!("\
+ execs().with_stdout(&format!("\
{updating} git repository `{bar}`
{compiling} [..]
{compiling} [..]
authors = []
[dependencies.bar]
git = '{}'
- "#, bar.url()).as_slice())
+ "#, bar.url()))
.file("src/main.rs", "fn main() {}");
assert_that(p2.cargo_process("build"),
- execs().with_stdout(format!("\
+ execs().with_stdout(&format!("\
{updating} git repository `{bar}`
{compiling} [..]
{compiling} [..]
name = "foo"
"#)
.file("src/foo.rs",
- main_file(r#""{}", bar::gimme()"#, &["bar"]).as_slice())
+ &main_file(r#""{}", bar::gimme()"#, &["bar"]))
.file("bar/Cargo.toml", r#"
[project]
pub fn gimme() -> i32 { 0 }
"#)
.file("bar/build.rs", r#"
- use std::old_io::fs;
- use std::old_path::{Path, GenericPath};
+ use std::fs;
fn main() {
- fs::copy(&Path::new("src/bar.rs.in"),
- &Path::new("src/bar.rs")).unwrap();
+ fs::copy("src/bar.rs.in", "src/bar.rs").unwrap();
}
"#)
}).unwrap();
authors = []
[dependencies.bar]
git = '{}'
- "#, bar.url()).as_slice())
+ "#, bar.url()))
.file("src/main.rs", "fn main() {}");
assert_that(p.cargo_process("fetch"),
- execs().with_status(0).with_stdout(format!("\
+ execs().with_status(0).with_stdout(&format!("\
{updating} git repository `{url}`
", updating = UPDATING, url = bar.url())));
authors = []
[dependencies.bar]
git = '{}'
- "#, bar.url()).as_slice())
+ "#, bar.url()))
.file("src/main.rs", "fn main() {}");
assert_that(p.cargo_process("build"),
execs()
- .with_stdout(format!("{} git repository `{}`\n\
+ .with_stdout(&format!("{} git repository `{}`\n\
{} bar v0.5.0 ({}#[..])\n\
{} foo v0.5.0 ({})\n",
UPDATING, bar.url(),
[dependencies.foo]
git = '{}'
- "#, foo2.url()).as_slice())
+ "#, foo2.url()))
.file("src/lib.rs", "")
}).unwrap();
git = '{}'
[dependencies.bar]
git = '{}'
- "#, foo1.url(), bar.url()).as_slice())
+ "#, foo1.url(), bar.url()))
.file("src/main.rs", "fn main() {}");
assert_that(p.cargo_process("generate-lockfile"), execs().with_status(0));
git = '{}'
[dependencies.a]
git = '{}'
- "#, foo.url(), foo.url()).as_slice())
+ "#, foo.url(), foo.url()))
.file("src/main.rs", "fn main() {}");
assert_that(p.cargo_process("generate-lockfile"), execs().with_status(0));
assert_that(p.cargo("update")
.arg("-p").arg("foo"),
execs().with_status(0)
- .with_stdout(format!("\
+ .with_stdout(&format!("\
Updating git repository `{}`
", foo.url())));
});
[dependencies.transitive]
git = '{}'
- "#, transitive.url()).as_slice())
+ "#, transitive.url()))
.file("src/lib.rs", "")
}).unwrap();
let dep2 = git_repo("dep2", |project| {
[dependencies.transitive]
git = '{}'
- "#, transitive.url()).as_slice())
+ "#, transitive.url()))
.file("src/lib.rs", "")
}).unwrap();
authors = []
[dependencies.dep]
git = '{}'
- "#, dep1.url()).as_slice())
+ "#, dep1.url()))
.file("src/main.rs", "fn main() {}");
p.build();
assert_that(p.cargo("build"),
execs().with_status(0)
- .with_stdout(format!("\
+ .with_stdout(&format!("\
Updating git repository `{}`
Updating git repository `{}`
{compiling} transitive [..]
assert_that(p.cargo("build"),
execs().with_status(0)
- .with_stdout(format!("\
+ .with_stdout(&format!("\
Updating git repository `{}`
{compiling} dep [..]
{compiling} project [..]
authors = []
[dependencies.dep]
git = '{}'
- "#, dep.url()).as_slice())
+ "#, dep.url()))
.file("src/main.rs", "fn main() {}");
p.build();
let mut lockfile = String::new();
File::open(&p.root().join("Cargo.lock")).unwrap()
.read_to_string(&mut lockfile).unwrap();
- assert!(!lockfile.contains(rev1.to_string().as_slice()),
+ assert!(!lockfile.contains(&rev1.to_string()),
"{} in {}", rev1, lockfile);
});
authors = []
[dependencies.a]
git = '{}'
- "#, a1.url()).as_slice())
+ "#, a1.url()))
.file("b/src/lib.rs", "fn main() {}");
p.build();
assert_that(p.cargo("build"),
execs().with_status(0)
- .with_stdout(format!("\
+ .with_stdout(&format!("\
{updating} git repository `file://[..]a1`
{compiling} a v0.5.0 ([..]a1#[..]
{compiling} b v0.5.0 ([..])
{compiling} project v0.5.0 ([..])
-", updating = UPDATING, compiling = COMPILING).as_slice()));
+", updating = UPDATING, compiling = COMPILING)));
File::create(&p.root().join("b/Cargo.toml")).unwrap().write_all(format!(r#"
[project]
assert_that(p.cargo("build"),
execs().with_status(0)
- .with_stdout(format!("\
+ .with_stdout(&format!("\
{updating} git repository `file://[..]a2`
{compiling} a v0.5.1 ([..]a2#[..]
{compiling} b v0.5.0 ([..])
{compiling} project v0.5.0 ([..])
-", updating = UPDATING, compiling = COMPILING).as_slice()));
+", updating = UPDATING, compiling = COMPILING)));
});
test!(dont_require_submodules_are_checked_out {
name = "foo"
"#)
.file("src/foo.rs",
- main_file(r#""{}", bar::gimme()"#, &["bar"]).as_slice())
+ &main_file(r#""{}", bar::gimme()"#, &["bar"]))
.file("bar/Cargo.toml", r#"
[project]
assert_that(p.cargo_process("build"),
execs().with_status(0)
- .with_stdout(format!("{} baz v0.5.0 ({})\n\
+ .with_stdout(&format!("{} baz v0.5.0 ({})\n\
{} bar v0.5.0 ({})\n\
{} foo v0.5.0 ({})\n",
COMPILING, p.url(),
println!("building baz");
assert_that(p.cargo("build").arg("-p").arg("baz"),
execs().with_status(0)
- .with_stdout(format!("{} baz v0.5.0 ({})\n",
+ .with_stdout(&format!("{} baz v0.5.0 ({})\n",
COMPILING, p.url())));
println!("building foo");
assert_that(p.cargo("build")
.arg("-p").arg("foo"),
execs().with_status(0)
- .with_stdout(format!("{} bar v0.5.0 ({})\n\
+ .with_stdout(&format!("{} bar v0.5.0 ({})\n\
{} foo v0.5.0 ({})\n",
COMPILING, p.url(),
COMPILING, p.url())));
name = "foo"
"#)
.file("src/main.rs",
- main_file(r#""{}", bar::gimme()"#, &["bar"]).as_slice());
+ &main_file(r#""{}", bar::gimme()"#, &["bar"]));
let p2 = project("bar")
.file("Cargo.toml", r#"
[package]
name = "foo"
"#)
.file("src/main.rs",
- main_file(r#""{}", bar::gimme()"#, &["bar"]).as_slice());
+ &main_file(r#""{}", bar::gimme()"#, &["bar"]));
let p2 = project("bar")
.file("Cargo.toml", r#"
[package]
p2.build();
assert_that(p.cargo_process("test"),
- execs().with_stdout(format!("\
+ execs().with_stdout(&format!("\
{compiling} [..] v0.5.0 ({url})
{compiling} [..] v0.5.0 ({url})
{running} target[..]foo-[..]
name = "foo"
"#)
.file("src/foo.rs",
- main_file(r#""{}", bar::gimme()"#, &["bar"]).as_slice())
+ &main_file(r#""{}", bar::gimme()"#, &["bar"]))
.file("bar/Cargo.toml", r#"
[project]
"#);
assert_that(p.cargo_process("build"),
- execs().with_stdout(format!("{} bar v0.5.0 ({})\n\
+ execs().with_stdout(&format!("{} bar v0.5.0 ({})\n\
{} foo v0.5.0 ({})\n",
COMPILING, p.url(),
COMPILING, p.url())));
"#);
// First time around we should compile both foo and bar
assert_that(p.cargo_process("build"),
- execs().with_stdout(format!("{} bar v0.5.0 ({})\n\
+ execs().with_stdout(&format!("{} bar v0.5.0 ({})\n\
{} foo v0.5.0 ({})\n",
COMPILING, p.url(),
COMPILING, p.url())));
p.build(); // rebuild the files (rewriting them in the process)
assert_that(p.cargo("build"),
- execs().with_stdout(format!("{} bar v0.5.0 ({})\n\
+ execs().with_stdout(&format!("{} bar v0.5.0 ({})\n\
{} foo v0.5.0 ({})\n",
COMPILING, p.url(),
COMPILING, p.url())));
pub fn baz() {}
"#);
assert_that(p.cargo_process("build"),
- execs().with_stdout(format!("{} baz v0.5.0 ({})\n\
+ execs().with_stdout(&format!("{} baz v0.5.0 ({})\n\
{} bar v0.5.0 ({})\n\
{} foo v0.5.0 ({})\n",
COMPILING, p.url(),
pub fn baz() { println!("hello!"); }
"#).unwrap();
assert_that(p.cargo("build"),
- execs().with_stdout(format!("{} baz v0.5.0 ({})\n\
+ execs().with_stdout(&format!("{} baz v0.5.0 ({})\n\
{} bar v0.5.0 ({})\n\
{} foo v0.5.0 ({})\n",
COMPILING, p.url(),
pub fn bar() { println!("hello!"); baz::baz(); }
"#).unwrap();
assert_that(p.cargo("build"),
- execs().with_stdout(format!("{} bar v0.5.0 ({})\n\
+ execs().with_stdout(&format!("{} bar v0.5.0 ({})\n\
{} foo v0.5.0 ({})\n",
COMPILING, p.url(),
COMPILING, p.url())));
pub fn baz() {}
"#);
assert_that(p.cargo_process("build"),
- execs().with_stdout(format!("{} baz v0.5.0 ({})\n\
+ execs().with_stdout(&format!("{} baz v0.5.0 ({})\n\
{} bar v0.5.0 ({})\n\
{} foo v0.5.0 ({})\n",
COMPILING, p.url(),
name = "foo"
"#)
.file("src/foo.rs",
- main_file(r#""{}", bar::gimme()"#, &["bar"]).as_slice())
+ &main_file(r#""{}", bar::gimme()"#, &["bar"]))
.file("src/bar/Cargo.toml", r#"
[project]
let bar = p.url();
assert_that(p.cargo_process("build"),
- execs().with_stdout(format!("{} bar v0.5.0 ({})\n\
+ execs().with_stdout(&format!("{} bar v0.5.0 ({})\n\
{} foo v0.5.0 ({})\n",
COMPILING, bar,
COMPILING, p.url())));
// This shouldn't recompile `bar`
assert_that(p.cargo("build"),
- execs().with_stdout(format!("{} foo v0.5.0 ({})\n",
+ execs().with_stdout(&format!("{} foo v0.5.0 ({})\n",
COMPILING, p.url())));
});
name = "foo"
"#)
.file("src/foo.rs",
- main_file(r#""{}", bar::gimme()"#, &["bar"]).as_slice())
+ &main_file(r#""{}", bar::gimme()"#, &["bar"]))
.file("bar/Cargo.toml", r#"
[project]
p.root().join("bar").move_into_the_past().unwrap();
assert_that(p.cargo("build"),
- execs().with_stdout(format!("{} bar v0.5.0 ({})\n\
+ execs().with_stdout(&format!("{} bar v0.5.0 ({})\n\
{} foo v0.5.0 ({})\n",
COMPILING, p.url(),
COMPILING, p.url())));
}
assert_that(p.cargo("build"),
- execs().with_stdout(format!("{} bar v0.5.0 ({})\n\
+ execs().with_stdout(&format!("{} bar v0.5.0 ({})\n\
{} foo v0.5.0 ({})\n",
COMPILING, p.url(),
COMPILING, p.url())));
assert_that(p.cargo("build")
.env("FOO", "bar"),
execs().with_status(0)
- .with_stdout(format!("{} foo v0.5.0 ({})\n",
+ .with_stdout(&format!("{} foo v0.5.0 ({})\n",
COMPILING, p.url())));
assert_that(p.cargo("test"),
execs().with_status(0)
- .with_stdout(format!("\
+ .with_stdout(&format!("\
{} [..] v0.5.0 ({})
{} [..] v0.5.0 ({})
Running target[..]foo-[..]
plugin = true
"#)
.file("bar/build.rs", r#"
- use std::old_io::fs;
- use std::old_path::{Path, GenericPath};
- use std::os;
+ #![feature(convert)]
+ use std::path::PathBuf;
+ use std::env;
fn main() {
- let src = Path::new(os::getenv("SRC").unwrap());
- println!("cargo:rustc-flags=-L {}", src.dir_path().display());
+ let src = PathBuf::from(env::var("SRC").unwrap());
+ println!("cargo:rustc-flags=-L {}", src.parent().unwrap()
+ .display());
}
"#)
.file("bar/src/lib.rs", &format!(r#"
- #![feature(plugin_registrar)]
-
+ #![feature(plugin_registrar, rustc_private)]
extern crate rustc;
use rustc::plugin::Registry;
fn disabled() -> bool {
// First, disable if ./configure requested so
match env::var("CFG_DISABLE_CROSS_TESTS") {
- Ok(ref s) if s.as_slice() == "1" => return true,
+ Ok(ref s) if *s == "1" => return true,
_ => {}
}
authors = []
build = "build.rs"
"#)
- .file("build.rs", format!(r#"
+ .file("build.rs", &format!(r#"
fn main() {{
- assert_eq!(std::env::var("TARGET").unwrap().as_slice(), "{}");
+ assert_eq!(std::env::var("TARGET").unwrap(), "{}");
}}
- "#, alternate()).as_slice())
+ "#, alternate()))
.file("src/main.rs", r#"
use std::env;
fn main() {
let target = alternate();
let p = project("foo")
- .file(".cargo/config", format!(r#"
+ .file(".cargo/config", &format!(r#"
[target.{}]
ar = "my-ar-tool"
linker = "my-linker-tool"
- "#, target).as_slice())
- .file("Cargo.toml", basic_bin_manifest("foo").as_slice())
+ "#, target))
+ .file("Cargo.toml", &basic_bin_manifest("foo"))
.file("src/foo.rs", r#"
use std::env;
fn main() {
assert_that(p.cargo_process("build").arg("--target").arg(target)
.arg("-v"),
execs().with_status(101)
- .with_stdout(format!("\
+ .with_stdout(&format!("\
{compiling} foo v0.5.0 ({url})
{running} `rustc src/foo.rs --crate-name foo --crate-type bin -g \
--out-dir {dir}[..]target[..]{target}[..]debug \
dir = p.root().display(),
url = p.url(),
target = target,
- ).as_slice()));
+ )));
});
test!(plugin_with_extra_dylib_dep {
let target = alternate();
assert_that(p.cargo_process("test").arg("--target").arg(target),
execs().with_status(0)
- .with_stdout(format!("\
+ .with_stdout(&format!("\
{compiling} foo v0.0.0 ({foo})
{running} target[..]{triple}[..]bar-[..]
authors = []
build = 'build.rs'
"#)
- .file("build.rs", format!(r#"
+ .file("build.rs", &format!(r#"
+ #![feature(convert)]
use std::env;
- use std::old_path::{{Path, GenericPath}};
+ use std::path::PathBuf;
fn main() {{
- assert_eq!(env::var("TARGET").unwrap().as_slice(), "{0}");
- let mut path = Path::new(env::var("OUT_DIR").unwrap());
- assert_eq!(path.filename().unwrap(), b"out");
+ assert_eq!(env::var("TARGET").unwrap(), "{0}");
+ let mut path = PathBuf::from(env::var_os("OUT_DIR").unwrap());
+ assert_eq!(path.file_name().unwrap().to_str().unwrap(), "out");
path.pop();
- assert!(path.filename().unwrap().starts_with(b"foo-"));
+ assert!(path.file_name().unwrap().to_str().unwrap()
+ .starts_with("foo-"));
path.pop();
- assert_eq!(path.filename().unwrap(), b"build");
+ assert_eq!(path.file_name().unwrap().to_str().unwrap(), "build");
path.pop();
- assert_eq!(path.filename().unwrap(), b"debug");
+ assert_eq!(path.file_name().unwrap().to_str().unwrap(), "debug");
path.pop();
- assert_eq!(path.filename().unwrap(), b"{0}");
+ assert_eq!(path.file_name().unwrap().to_str().unwrap(), "{0}");
path.pop();
- assert_eq!(path.filename().unwrap(), b"target");
+ assert_eq!(path.file_name().unwrap().to_str().unwrap(), "target");
}}
- "#, target).as_slice())
+ "#, target))
.file("src/main.rs", "fn main() {}");
assert_that(p.cargo_process("build").arg("--target").arg(&target).arg("-v"),
execs().with_status(0)
- .with_stdout(format!("\
+ .with_stdout(&format!("\
{compiling} foo v0.0.0 (file://[..])
{running} `rustc build.rs [..] --out-dir {dir}[..]target[..]build[..]foo-[..]`
{running} `{dir}[..]target[..]build[..]foo-[..]build-script-build`
{running} `rustc src[..]main.rs [..] --target {target} [..]`
", compiling = COMPILING, running = RUNNING, target = target,
- dir = p.root().display()).as_slice()));
+ dir = p.root().display())));
});
test!(build_script_needed_for_host_and_target {
assert_that(p.cargo_process("build").arg("--target").arg(&target).arg("-v"),
execs().with_status(0)
- .with_stdout(format!("\
+ .with_stdout(&format!("\
{compiling} d1 v0.0.0 (file://{dir})
{running} `rustc d1[..]build.rs [..] --out-dir {dir}[..]target[..]build[..]d1-[..]`
{running} `{dir}[..]target[..]build[..]d1-[..]build-script-build`
{running} `rustc src[..]main.rs [..] --target {target} [..] \
-L /path/to/{target}`
", compiling = COMPILING, running = RUNNING, target = target, host = host,
- dir = p.root().display()).as_slice()));
+ dir = p.root().display())));
});
test!(build_deps_for_the_right_arch {
assert_that(p.cargo_process("build").arg("-v").arg("--target").arg(alternate()),
execs().with_status(0)
- .with_stdout(format!("\
+ .with_stdout(&format!("\
{compiling} foo v0.0.1 ([..])
{running} `rustc build.rs [..]`
{running} `[..]build-script-build[..]`
"#);
assert_that(p.cargo_process("doc"),
- execs().with_status(0).with_stdout(format!("\
+ execs().with_status(0).with_stdout(&format!("\
{compiling} foo v0.0.1 ({dir})
",
compiling = COMPILING,
- dir = path2url(p.root())).as_slice()));
+ dir = path2url(p.root()))));
assert_that(&p.root().join("target/doc"), existing_dir());
assert_that(&p.root().join("target/doc/foo/index.html"), existing_file());
});
"#);
assert_that(p.cargo_process("doc"),
- execs().with_status(0).with_stdout(format!("\
+ execs().with_status(0).with_stdout(&format!("\
{compiling} foo v0.0.1 ({dir})
",
compiling = COMPILING,
- dir = path2url(p.root())).as_slice()));
+ dir = path2url(p.root()))));
assert_that(p.cargo("doc"),
execs().with_status(0).with_stdout(""))
"#);
assert_that(p.cargo_process("doc"),
- execs().with_status(0).with_stdout(format!("\
+ execs().with_status(0).with_stdout(&format!("\
{compiling} bar v0.0.1 ({dir})
{compiling} foo v0.0.1 ({dir})
",
compiling = COMPILING,
- dir = path2url(p.root())).as_slice()));
+ dir = path2url(p.root()))));
assert_that(&p.root().join("target/doc"), existing_dir());
assert_that(&p.root().join("target/doc/foo/index.html"), existing_file());
"#);
assert_that(p.cargo_process("doc").arg("--no-deps"),
- execs().with_status(0).with_stdout(format!("\
+ execs().with_status(0).with_stdout(&format!("\
{compiling} bar v0.0.1 ({dir})
{compiling} foo v0.0.1 ({dir})
",
compiling = COMPILING,
- dir = path2url(p.root())).as_slice()));
+ dir = path2url(p.root()))));
assert_that(&p.root().join("target/doc"), existing_dir());
assert_that(&p.root().join("target/doc/foo/index.html"), existing_file());
assert_that(p.cargo_process("doc").arg("-p").arg("a"),
execs().with_status(0)
- .with_stdout(format!("\
+ .with_stdout(&format!("\
{compiling} b v0.0.1 (file://[..])
{compiling} a v0.0.1 (file://[..])
-", compiling = COMPILING).as_slice()));
+", compiling = COMPILING)));
});
test!(doc_same_name {
.file("src/main.rs", "");
assert_that(p.cargo_process("build"),
- execs().with_status(101).with_stderr(format!("\
+ execs().with_status(101).with_stderr(&format!("\
failed to parse manifest at `[..]`
Caused by:
Feature `bar` includes `baz` which is neither a dependency nor another feature
-").as_slice()));
+")));
});
test!(invalid2 {
.file("src/main.rs", "");
assert_that(p.cargo_process("build"),
- execs().with_status(101).with_stderr(format!("\
+ execs().with_status(101).with_stderr(&format!("\
failed to parse manifest at `[..]`
Caused by:
Features and dependencies cannot have the same name: `bar`
-").as_slice()));
+")));
});
test!(invalid3 {
.file("src/main.rs", "");
assert_that(p.cargo_process("build"),
- execs().with_status(101).with_stderr(format!("\
+ execs().with_status(101).with_stderr(&format!("\
failed to parse manifest at `[..]`
Caused by:
Feature `bar` depends on `baz` which is not an optional dependency.
Consider adding `optional = true` to the dependency
-").as_slice()));
+")));
});
test!(invalid4 {
.file("bar/src/lib.rs", "");
assert_that(p.cargo_process("build"),
- execs().with_status(101).with_stderr(format!("\
+ execs().with_status(101).with_stderr(&format!("\
Package `bar v0.0.1 ([..])` does not have these features: `bar`
-").as_slice()));
+")));
let p = p.file("Cargo.toml", r#"
[project]
"#);
assert_that(p.cargo_process("build").arg("--features").arg("test"),
- execs().with_status(101).with_stderr(format!("\
+ execs().with_status(101).with_stderr(&format!("\
Package `foo v0.0.1 ([..])` does not have these features: `test`
-").as_slice()));
+")));
});
test!(invalid5 {
.file("src/main.rs", "");
assert_that(p.cargo_process("build"),
- execs().with_status(101).with_stderr(format!("\
+ execs().with_status(101).with_stderr(&format!("\
failed to parse manifest at `[..]`
Caused by:
Dev-dependencies are not allowed to be optional: `bar`
-").as_slice()));
+")));
});
test!(invalid6 {
.file("src/main.rs", "");
assert_that(p.cargo_process("build").arg("--features").arg("foo"),
- execs().with_status(101).with_stderr(format!("\
+ execs().with_status(101).with_stderr(&format!("\
failed to parse manifest at `[..]`
Caused by:
Feature `foo` requires `bar` which is not an optional dependency
-").as_slice()));
+")));
});
test!(invalid7 {
.file("src/main.rs", "");
assert_that(p.cargo_process("build").arg("--features").arg("foo"),
- execs().with_status(101).with_stderr(format!("\
+ execs().with_status(101).with_stderr(&format!("\
failed to parse manifest at `[..]`
Caused by:
Feature `foo` requires `bar` which is not an optional dependency
-").as_slice()));
+")));
});
test!(invalid8 {
.file("bar/src/lib.rs", "");
assert_that(p.cargo_process("build").arg("--features").arg("foo"),
- execs().with_status(101).with_stderr(format!("\
+ execs().with_status(101).with_stderr(&format!("\
features in dependencies cannot enable features in other dependencies: `foo/bar`
-").as_slice()));
+")));
});
test!(no_feature_doesnt_build {
assert_that(p.cargo_process("build"),
execs().with_status(0).with_stdout(format!("\
{compiling} foo v0.0.1 ({dir})
-", compiling = COMPILING, dir = p.url()).as_slice()));
+", compiling = COMPILING, dir = p.url())));
assert_that(p.process(&p.bin("foo")),
execs().with_status(0).with_stdout(""));
execs().with_status(0).with_stdout(format!("\
{compiling} bar v0.0.1 ({dir})
{compiling} foo v0.0.1 ({dir})
-", compiling = COMPILING, dir = p.url()).as_slice()));
+", compiling = COMPILING, dir = p.url())));
assert_that(p.process(&p.bin("foo")),
execs().with_status(0).with_stdout("bar\n"));
});
execs().with_status(0).with_stdout(format!("\
{compiling} bar v0.0.1 ({dir})
{compiling} foo v0.0.1 ({dir})
-", compiling = COMPILING, dir = p.url()).as_slice()));
+", compiling = COMPILING, dir = p.url())));
assert_that(p.process(&p.bin("foo")),
execs().with_status(0).with_stdout("bar\n"));
assert_that(p.cargo("build").arg("--no-default-features"),
execs().with_status(0).with_stdout(format!("\
{compiling} foo v0.0.1 ({dir})
-", compiling = COMPILING, dir = p.url()).as_slice()));
+", compiling = COMPILING, dir = p.url())));
assert_that(p.process(&p.bin("foo")),
execs().with_status(0).with_stdout(""));
});
{compiling} ba[..] v0.0.1 ({dir})
{compiling} ba[..] v0.0.1 ({dir})
{compiling} foo v0.0.1 ({dir})
-", compiling = COMPILING, dir = p.url()).as_slice()));
+", compiling = COMPILING, dir = p.url())));
});
test!(many_cli_features {
{compiling} ba[..] v0.0.1 ({dir})
{compiling} ba[..] v0.0.1 ({dir})
{compiling} foo v0.0.1 ({dir})
-", compiling = COMPILING, dir = p.url()).as_slice()));
+", compiling = COMPILING, dir = p.url())));
});
test!(union_features {
{compiling} d2 v0.0.1 ({dir})
{compiling} d1 v0.0.1 ({dir})
{compiling} foo v0.0.1 ({dir})
-", compiling = COMPILING, dir = p.url()).as_slice()));
+", compiling = COMPILING, dir = p.url())));
});
test!(many_features_no_rebuilds {
execs().with_status(0).with_stdout(format!("\
{compiling} a v0.1.0 ({dir})
{compiling} b v0.1.0 ({dir})
-", compiling = COMPILING, dir = p.url()).as_slice()));
+", compiling = COMPILING, dir = p.url())));
p.root().move_into_the_past().unwrap();
assert_that(p.cargo("build").arg("-v"),
execs().with_status(0).with_stdout(format!("\
{fresh} a v0.1.0 ([..])
{fresh} b v0.1.0 ([..])
-", fresh = FRESH).as_slice()));
+", fresh = FRESH)));
});
// Tests that all cmd lines work with `--features ""`
.file("src/bar.txt", ""); // should be ignored when packaging
assert_that(p.cargo_process("package"),
- execs().with_status(0).with_stdout(format!("\
+ execs().with_status(0).with_stdout(&format!("\
{packaging} foo v0.0.1 ({dir})
{verifying} foo v0.0.1 ({dir})
{compiling} foo v0.0.1 ({dir}[..])
packaging = PACKAGING,
verifying = VERIFYING,
compiling = COMPILING,
- dir = p.url()).as_slice()));
+ dir = p.url())));
assert_that(&p.root().join("target/package/foo-0.0.1.crate"), existing_file());
assert_that(p.cargo("package").arg("-l"),
execs().with_status(0).with_stdout("\
fn main() {}
"#);
assert_that(p.cargo_process("package"),
- execs().with_status(0).with_stdout(format!("\
+ execs().with_status(0).with_stdout(&format!("\
{packaging} foo v0.0.1 ({dir})
{verifying} foo v0.0.1 ({dir})
{compiling} foo v0.0.1 ({dir}[..])
packaging = PACKAGING,
verifying = VERIFYING,
compiling = COMPILING,
- dir = p.url()).as_slice())
+ dir = p.url()))
.with_stderr("\
warning: manifest has no description, license, license-file, documentation, \
homepage or repository. See \
fn main() {}
"#);
assert_that(p.cargo_process("package"),
- execs().with_status(0).with_stdout(format!("\
+ execs().with_status(0).with_stdout(&format!("\
{packaging} foo v0.0.1 ({dir})
{verifying} foo v0.0.1 ({dir})
{compiling} foo v0.0.1 ({dir}[..])
packaging = PACKAGING,
verifying = VERIFYING,
compiling = COMPILING,
- dir = p.url()).as_slice())
+ dir = p.url()))
.with_stderr("\
warning: manifest has no description, documentation, homepage or repository. See \
http://doc.crates.io/manifest.html#package-metadata for more info."));
fn main() {}
"#);
assert_that(p.cargo_process("package"),
- execs().with_status(0).with_stdout(format!("\
+ execs().with_status(0).with_stdout(&format!("\
{packaging} foo v0.0.1 ({dir})
{verifying} foo v0.0.1 ({dir})
{compiling} foo v0.0.1 ({dir}[..])
packaging = PACKAGING,
verifying = VERIFYING,
compiling = COMPILING,
- dir = p.url()).as_slice()));
+ dir = p.url())));
});
test!(package_verbose {
let mut cargo = process(&cargo_dir().join("cargo")).unwrap();
cargo.cwd(&root).env("HOME", &paths::home());
assert_that(cargo.clone().arg("build"), execs().with_status(0));
- assert_that(cargo.arg("package").arg("-v")
- .arg("--no-verify"),
- execs().with_status(0).with_stdout(format!("\
+ assert_that(cargo.arg("package").arg("-v").arg("--no-verify"),
+ execs().with_status(0).with_stdout(&format!("\
{packaging} foo v0.0.1 ([..])
{archiving} [..]
{archiving} [..]
",
packaging = PACKAGING,
- archiving = ARCHIVING).as_slice()));
+ archiving = ARCHIVING)));
});
test!(package_verification {
assert_that(p.cargo_process("build"),
execs().with_status(0));
assert_that(p.cargo("package"),
- execs().with_status(0).with_stdout(format!("\
+ execs().with_status(0).with_stdout(&format!("\
{packaging} foo v0.0.1 ({dir})
{verifying} foo v0.0.1 ({dir})
{compiling} foo v0.0.1 ({dir}[..])
packaging = PACKAGING,
verifying = VERIFYING,
compiling = COMPILING,
- dir = p.url()).as_slice()));
+ dir = p.url())));
});
test!(exclude {
.file("src/bar.txt", "");
assert_that(p.cargo_process("package").arg("--no-verify").arg("-v"),
- execs().with_status(0).with_stdout(format!("\
+ execs().with_status(0).with_stdout(&format!("\
{packaging} foo v0.0.1 ([..])
{archiving} [..]
{archiving} [..]
-", packaging = PACKAGING, archiving = ARCHIVING).as_slice()));
+", packaging = PACKAGING, archiving = ARCHIVING)));
});
test!(include {
.file("src/bar.txt", ""); // should be ignored when packaging
assert_that(p.cargo_process("package").arg("--no-verify").arg("-v"),
- execs().with_status(0).with_stdout(format!("\
+ execs().with_status(0).with_stdout(&format!("\
{packaging} foo v0.0.1 ([..])
{archiving} [..]
{archiving} [..]
{archiving} [..]
-", packaging = PACKAGING, archiving = ARCHIVING).as_slice()));
+", packaging = PACKAGING, archiving = ARCHIVING)));
});
test!(package_lib_with_bin {
"#)
.file("src/lib.rs", "");
assert_that(p.cargo_process("build").arg("-v"),
- execs().with_status(0).with_stdout(format!("\
+ execs().with_status(0).with_stdout(&format!("\
{compiling} test v0.0.0 ({url})
{running} `rustc src{sep}lib.rs --crate-name test --crate-type lib \
-C opt-level=1 \
"#)
.file("foo/src/lib.rs", "");
assert_that(p.cargo_process("build").arg("-v").arg("--release"),
- execs().with_status(0).with_stdout(format!("\
+ execs().with_status(0).with_stdout(&format!("\
{compiling} foo v0.0.0 ({url})
{running} `rustc foo{sep}src{sep}lib.rs --crate-name foo \
--crate-type dylib --crate-type rlib -C prefer-dynamic \
url = p.url(),
sep = SEP,
prefix = env::consts::DLL_PREFIX,
- suffix = env::consts::DLL_SUFFIX).as_slice()));
+ suffix = env::consts::DLL_SUFFIX)));
});
.file("src/main.rs", "fn main() {}");
assert_that(p.cargo_process("publish").arg("--no-verify"),
- execs().with_status(0).with_stdout(format!("\
+ execs().with_status(0).with_stdout(&format!("\
{updating} registry `{reg}`
{packaging} foo v0.0.1 ({dir})
{uploading} foo v0.0.1 ({dir})
uploading = UPLOADING,
packaging = PACKAGING,
dir = p.url(),
- reg = registry()).as_slice()));
+ reg = registry())));
let mut f = File::open(&upload_path().join("api/v1/crates/new")).unwrap();
// Skip the metadata payload and the size of the tarball
r::mock_pkg("bar", "0.0.1", &[]);
assert_that(p.cargo_process("build"),
- execs().with_status(0).with_stdout(format!("\
+ execs().with_status(0).with_stdout(&format!("\
{updating} registry `{reg}`
{downloading} bar v0.0.1 (registry file://[..])
{compiling} bar v0.0.1 (registry file://[..])
downloading = DOWNLOADING,
compiling = COMPILING,
dir = p.url(),
- reg = r::registry()).as_slice()));
+ reg = r::registry())));
// Don't download a second time
assert_that(p.cargo_process("build"),
- execs().with_status(0).with_stdout(format!("\
+ execs().with_status(0).with_stdout(&format!("\
{updating} registry `{reg}`
[..] bar v0.0.1 (registry file://[..])
[..] foo v0.0.1 ({dir})
",
updating = UPDATING,
dir = p.url(),
- reg = r::registry()).as_slice()));
+ reg = r::registry())));
});
test!(deps {
r::mock_pkg("bar", "0.0.1", &[("baz", "*", "normal")]);
assert_that(p.cargo_process("build"),
- execs().with_status(0).with_stdout(format!("\
+ execs().with_status(0).with_stdout(&format!("\
{updating} registry `{reg}`
{downloading} [..] v0.0.1 (registry file://[..])
{downloading} [..] v0.0.1 (registry file://[..])
downloading = DOWNLOADING,
compiling = COMPILING,
dir = p.url(),
- reg = r::registry()).as_slice()));
+ reg = r::registry())));
});
test!(nonexistent {
r::mock_pkg("notyet", "0.0.1", &[]);
assert_that(p.cargo("build"),
- execs().with_status(0).with_stdout(format!("\
+ execs().with_status(0).with_stdout(&format!("\
{updating} registry `{reg}`
{downloading} notyet v0.0.1 (registry file://[..])
{compiling} notyet v0.0.1 (registry file://[..])
downloading = DOWNLOADING,
compiling = COMPILING,
dir = p.url(),
- reg = r::registry()).as_slice()));
+ reg = r::registry())));
});
test!(package_with_path_deps {
r::mock_pkg("bar", "0.0.1", &[]);
assert_that(p.cargo("build"),
- execs().with_status(0).with_stdout(format!("\
+ execs().with_status(0).with_stdout(&format!("\
{updating} registry `[..]`
{downloading} bar v0.0.1 (registry file://[..])
{compiling} bar v0.0.1 (registry file://[..])
{compiling} foo v0.0.1 ({dir})
", updating = UPDATING, downloading = DOWNLOADING, compiling = COMPILING,
- dir = p.url()).as_slice()));
+ dir = p.url())));
p.root().move_into_the_past().unwrap();
r::mock_pkg("bar", "0.0.2", &[]);
r::mock_pkg("bar", "0.0.1", &[("baz", "*", "normal")]);
assert_that(p.cargo("build"),
- execs().with_status(0).with_stdout(format!("\
+ execs().with_status(0).with_stdout(&format!("\
{updating} registry `[..]`
{downloading} [..] v0.0.1 (registry file://[..])
{downloading} [..] v0.0.1 (registry file://[..])
{compiling} bar v0.0.1 (registry file://[..])
{compiling} foo v0.0.1 ({dir})
", updating = UPDATING, downloading = DOWNLOADING, compiling = COMPILING,
- dir = p.url()).as_slice()));
+ dir = p.url())));
p.root().move_into_the_past().unwrap();
r::mock_pkg("baz", "0.0.2", &[]);
r::mock_pkg_yank("bar", "0.0.2", &[("baz", "*", "normal")], true);
assert_that(p.cargo("build"),
- execs().with_status(0).with_stdout(format!("\
+ execs().with_status(0).with_stdout(&format!("\
{updating} registry `[..]`
{downloading} [..] v0.0.1 (registry file://[..])
{downloading} [..] v0.0.1 (registry file://[..])
{compiling} bar v0.0.1 (registry file://[..])
{compiling} foo v0.0.1 ({dir})
", updating = UPDATING, downloading = DOWNLOADING, compiling = COMPILING,
- dir = p.url()).as_slice()));
+ dir = p.url())));
});
test!(relying_on_a_yank_is_bad {
paths::home().join(".cargo/registry").rm_rf().unwrap();
assert_that(p.cargo("build"),
- execs().with_status(0).with_stdout(format!("\
+ execs().with_status(0).with_stdout(&format!("\
{updating} registry `[..]`
{downloading} bar v0.0.1 (registry file://[..])
-", updating = UPDATING, downloading = DOWNLOADING).as_slice()));
+", updating = UPDATING, downloading = DOWNLOADING)));
});
test!(update_lockfile {
println!("0.0.2 update");
assert_that(p.cargo("update")
.arg("-p").arg("bar").arg("--precise").arg("0.0.2"),
- execs().with_status(0).with_stdout(format!("\
+ execs().with_status(0).with_stdout(&format!("\
{updating} registry `[..]`
-", updating = UPDATING).as_slice()));
+", updating = UPDATING)));
println!("0.0.2 build");
assert_that(p.cargo("build"),
- execs().with_status(0).with_stdout(format!("\
+ execs().with_status(0).with_stdout(&format!("\
{downloading} [..] v0.0.2 (registry file://[..])
{compiling} bar v0.0.2 (registry file://[..])
{compiling} foo v0.0.1 ({dir})
", downloading = DOWNLOADING, compiling = COMPILING,
- dir = p.url()).as_slice()));
+ dir = p.url())));
println!("0.0.3 update");
assert_that(p.cargo("update")
.arg("-p").arg("bar"),
- execs().with_status(0).with_stdout(format!("\
+ execs().with_status(0).with_stdout(&format!("\
{updating} registry `[..]`
-", updating = UPDATING).as_slice()));
+", updating = UPDATING)));
println!("0.0.3 build");
assert_that(p.cargo("build"),
- execs().with_status(0).with_stdout(format!("\
+ execs().with_status(0).with_stdout(&format!("\
{downloading} [..] v0.0.3 (registry file://[..])
{compiling} bar v0.0.3 (registry file://[..])
{compiling} foo v0.0.1 ({dir})
", downloading = DOWNLOADING, compiling = COMPILING,
- dir = p.url()).as_slice()));
+ dir = p.url())));
});
test!(dev_dependency_not_used {
r::mock_pkg("bar", "0.0.1", &[("baz", "*", "dev")]);
assert_that(p.cargo("build"),
- execs().with_status(0).with_stdout(format!("\
+ execs().with_status(0).with_stdout(&format!("\
{updating} registry `[..]`
{downloading} [..] v0.0.1 (registry file://[..])
{compiling} bar v0.0.1 (registry file://[..])
{compiling} foo v0.0.1 ({dir})
", updating = UPDATING, downloading = DOWNLOADING, compiling = COMPILING,
- dir = p.url()).as_slice()));
+ dir = p.url())));
});
test!(login_with_no_cargo_dir {
r::mock_pkg("bar", "0.0.1", &[]);
assert_that(p.cargo("build"),
- execs().with_status(0).with_stdout(format!("\
+ execs().with_status(0).with_stdout(&format!("\
{updating} registry `[..]`
{downloading} bar v0.0.1 (registry file://[..])
{compiling} bar v0.0.1 (registry file://[..])
{compiling} a v0.0.1 ({dir})
{compiling} foo v0.0.1 ({dir})
", updating = UPDATING, downloading = DOWNLOADING, compiling = COMPILING,
- dir = p.url()).as_slice()));
+ dir = p.url())));
File::create(&p.root().join("a/Cargo.toml")).unwrap().write_all(br#"
[project]
println!("second");
assert_that(p.cargo("build"),
- execs().with_status(0).with_stdout(format!("\
+ execs().with_status(0).with_stdout(&format!("\
{updating} registry `[..]`
{downloading} bar v0.1.0 (registry file://[..])
{compiling} bar v0.1.0 (registry file://[..])
{compiling} a v0.0.1 ({dir})
{compiling} foo v0.0.1 ({dir})
", updating = UPDATING, downloading = DOWNLOADING, compiling = COMPILING,
- dir = p.url()).as_slice()));
+ dir = p.url())));
});
test!(git_and_registry_dep {
p.root().move_into_the_past().unwrap();
assert_that(p.cargo("build"),
- execs().with_status(0).with_stdout(format!("\
+ execs().with_status(0).with_stdout(&format!("\
{updating} [..]
{updating} [..]
{downloading} a v0.0.1 (registry file://[..])
{compiling} b v0.0.1 ([..])
{compiling} foo v0.0.1 ({dir})
", updating = UPDATING, downloading = DOWNLOADING, compiling = COMPILING,
- dir = p.url()).as_slice()));
+ dir = p.url())));
p.root().move_into_the_past().unwrap();
println!("second");
fs::remove_dir_all(&p.root().join("target")).unwrap();
assert_that(p.cargo("build"),
- execs().with_status(0).with_stdout(format!("\
+ execs().with_status(0).with_stdout(&format!("\
{updating} [..]
{downloading} a v0.1.1 (registry file://[..])
{compiling} a v0.1.1 (registry [..])
{compiling} foo v0.5.0 ({dir})
", updating = UPDATING, downloading = DOWNLOADING, compiling = COMPILING,
- dir = p.url()).as_slice()));
+ dir = p.url())));
});
"#);
assert_that(p.cargo_process("run"),
- execs().with_status(0).with_stdout(format!("\
+ execs().with_status(0).with_stdout(&format!("\
{compiling} foo v0.0.1 ({dir})
{running} `target{sep}debug{sep}foo[..]`
hello
compiling = COMPILING,
running = RUNNING,
dir = path2url(p.root()),
- sep = SEP).as_slice()));
+ sep = SEP)));
assert_that(&p.bin("foo"), existing_file());
});
"#)
.file("src/main.rs", r#"
fn main() {
- assert_eq!(std::os::args()[1].as_slice(), "hello");
- assert_eq!(std::os::args()[2].as_slice(), "world");
+ assert_eq!(std::env::args().nth(1).unwrap(), "hello");
+ assert_eq!(std::env::args().nth(2).unwrap(), "world");
}
"#);
authors = []
"#)
.file("src/main.rs", r#"
- fn main() { std::os::set_exit_status(2); }
+ #![feature(exit_status)]
+ fn main() { std::env::set_exit_status(2); }
"#);
assert_that(p.cargo_process("run"),
"#);
assert_that(p.cargo_process("run").arg("--bin").arg("a").arg("-v"),
- execs().with_status(0).with_stdout(format!("\
+ execs().with_status(0).with_stdout(&format!("\
{compiling} foo v0.0.1 ({dir})
{running} `rustc src[..]lib.rs [..]`
{running} `rustc src[..]a.rs [..]`
compiling = COMPILING,
running = RUNNING,
dir = path2url(p.root()),
- sep = SEP).as_slice()));
+ sep = SEP)));
assert_that(p.cargo("run").arg("--bin").arg("b").arg("-v"),
- execs().with_status(0).with_stdout(format!("\
+ execs().with_status(0).with_stdout(&format!("\
{compiling} foo v0.0.1 ([..])
{running} `rustc src[..]b.rs [..]`
{running} `target{sep}debug{sep}b[..]`
hello b.rs
",
running = RUNNING, compiling = COMPILING,
- sep = SEP).as_slice()));
+ sep = SEP)));
});
test!(run_example {
"#);
assert_that(p.cargo_process("run").arg("--example").arg("a"),
- execs().with_status(0).with_stdout(format!("\
+ execs().with_status(0).with_stdout(&format!("\
{compiling} foo v0.0.1 ({dir})
{running} `target{sep}debug{sep}examples{sep}a[..]`
example
compiling = COMPILING,
running = RUNNING,
dir = path2url(p.root()),
- sep = SEP).as_slice()));
+ sep = SEP)));
});
test!(either_name_or_example {
"#);
assert_that(p.cargo_process("run"),
- execs().with_status(0).with_stdout(format!("\
+ execs().with_status(0).with_stdout(&format!("\
{compiling} foo v0.0.1 ({dir})
{running} `target{sep}debug{sep}main[..]`
hello main.rs
compiling = COMPILING,
running = RUNNING,
dir = path2url(p.root()),
- sep = SEP).as_slice()));
+ sep = SEP)));
});
test!(example_with_release_flag {
"#);
assert_that(p.cargo_process("run").arg("-v").arg("--release").arg("--example").arg("a"),
- execs().with_status(0).with_stdout(format!("\
+ execs().with_status(0).with_stdout(&format!("\
{compiling} bar v0.0.1 ({url})
{running} `rustc bar{sep}src{sep}bar.rs --crate-name bar --crate-type lib \
-C opt-level=3 \
running = RUNNING,
dir = p.root().display(),
url = path2url(p.root()),
- sep = SEP).as_slice()));
+ sep = SEP)));
assert_that(p.cargo("run").arg("-v").arg("--example").arg("a"),
- execs().with_status(0).with_stdout(format!("\
+ execs().with_status(0).with_stdout(&format!("\
{compiling} bar v0.0.1 ({url})
{running} `rustc bar{sep}src{sep}bar.rs --crate-name bar --crate-type lib \
-g \
running = RUNNING,
dir = p.root().display(),
url = path2url(p.root()),
- sep = SEP).as_slice()));
+ sep = SEP)));
});
test!(run_dylib_dep {
"#);
assert_that(p.cargo_process("run").arg("--release"),
- execs().with_status(0).with_stdout(format!("\
+ execs().with_status(0).with_stdout(&format!("\
{compiling} foo v0.0.1 ({dir})
{running} `target{sep}release{sep}foo[..]`
",
compiling = COMPILING,
running = RUNNING,
dir = path2url(p.root()),
- sep = SEP).as_slice()));
+ sep = SEP)));
assert_that(&p.release_bin("foo"), existing_file());
});
test!(cargo_test_simple {
let p = project("foo")
- .file("Cargo.toml", basic_bin_manifest("foo").as_slice())
+ .file("Cargo.toml", &basic_bin_manifest("foo"))
.file("src/foo.rs", r#"
fn hello() -> &'static str {
"hello"
test!(cargo_test_verbose {
let p = project("foo")
- .file("Cargo.toml", basic_bin_manifest("foo").as_slice())
+ .file("Cargo.toml", &basic_bin_manifest("foo"))
.file("src/foo.rs", r#"
fn main() {}
#[test] fn test_hello() {}
test!(cargo_test_failing_test {
let p = project("foo")
- .file("Cargo.toml", basic_bin_manifest("foo").as_slice())
+ .file("Cargo.toml", &basic_bin_manifest("foo"))
.file("src/foo.rs", r#"
fn hello() -> &'static str {
"hello"
p2.build();
assert_that(p.cargo_process("test"),
execs().with_status(0)
- .with_stdout(format!("\
+ .with_stdout(&format!("\
{compiling} foo v0.0.1 ({dir})
{compiling} bar v0.0.1 ({dir})
{running} target[..]
",
compiling = COMPILING, running = RUNNING,
doctest = DOCTEST,
- dir = p.url()).as_slice()));
+ dir = p.url())));
});
test!(external_test_explicit {
assert_that(p.cargo_process("test").arg("bar"),
execs().with_status(0)
- .with_stdout(format!("\
+ .with_stdout(&format!("\
{compiling} foo v0.0.1 ({dir})
{running} target[..]foo-[..]
",
compiling = COMPILING, running = RUNNING,
doctest = DOCTEST,
- dir = p.url()).as_slice()));
+ dir = p.url())));
assert_that(p.cargo_process("test").arg("foo"),
execs().with_status(0)
- .with_stdout(format!("\
+ .with_stdout(&format!("\
{compiling} foo v0.0.1 ({dir})
{running} target[..]foo-[..]
",
compiling = COMPILING, running = RUNNING,
doctest = DOCTEST,
- dir = p.url()).as_slice()));
+ dir = p.url())));
});
// Regression test for running cargo-test twice with
// tests in an rlib
test!(cargo_test_twice {
let p = project("test_twice")
- .file("Cargo.toml", basic_lib_manifest("test_twice").as_slice())
+ .file("Cargo.toml", &basic_lib_manifest("test_twice"))
.file("src/test_twice.rs", r#"
#![crate_type = "rlib"]
assert_that(p.cargo_process("test"),
execs().with_status(0)
- .with_stdout(format!("\
+ .with_stdout(&format!("\
{compiling} syntax v0.0.1 ({dir})
{running} target[..]syntax-[..]
",
compiling = COMPILING, running = RUNNING,
- doctest = DOCTEST, dir = p.url()).as_slice()));
+ doctest = DOCTEST, dir = p.url())));
});
test!(lib_with_standard_name2 {
assert_that(p.cargo_process("test"),
execs().with_status(0)
- .with_stdout(format!("\
+ .with_stdout(&format!("\
{compiling} syntax v0.0.1 ({dir})
{running} target[..]syntax-[..]
",
compiling = COMPILING, running = RUNNING,
- dir = p.url()).as_slice()));
+ dir = p.url())));
});
test!(bin_there_for_integration {
authors = []
"#)
.file("src/main.rs", "
- fn main() { std::os::set_exit_status(1); }
+ fn main() { panic!(); }
#[test] fn main_test() {}
")
.file("tests/foo.rs", r#"
- use std::old_io::Command;
+ use std::process::Command;
#[test]
fn test_test() {
let status = Command::new("target/debug/foo").status().unwrap();
- assert!(status.matches_exit_status(1));
+ assert_eq!(status.code(), Some(101));
}
"#);
assert_that(p.cargo_process("test"),
execs().with_status(0)
- .with_stdout(format!("\
+ .with_stdout(&format!("\
{compiling} bar v0.0.1 ({dir})
{compiling} foo v0.0.1 ({dir})
{running} target[..]foo-[..]
",
compiling = COMPILING, running = RUNNING,
doctest = DOCTEST,
- dir = p.url()).as_slice()));
+ dir = p.url())));
p.root().move_into_the_past().unwrap();
assert_that(p.cargo("test"),
execs().with_status(0)
assert_that(p.cargo_process("test"),
execs().with_status(0)
- .with_stdout(format!("\
+ .with_stdout(&format!("\
{compiling} foo v0.0.1 ({dir})
{running} target[..]foo-[..]
",
compiling = COMPILING, running = RUNNING,
doctest = DOCTEST,
- dir = p.url()).as_slice()));
+ dir = p.url())));
assert_that(p.cargo("test"),
execs().with_status(0)
assert_that(p.cargo_process("test"),
execs().with_status(0)
- .with_stdout(format!("\
+ .with_stdout(&format!("\
{compiling} foo v0.0.1 ({dir})
{running} target[..]foo-[..]
",
compiling = COMPILING, running = RUNNING,
doctest = DOCTEST,
- dir = p.url()).as_slice()));
+ dir = p.url())));
assert_that(p.cargo("build"),
execs().with_status(0)
assert_that(p.cargo_process("test").arg("--no-run"),
execs().with_status(0)
- .with_stdout(format!("\
+ .with_stdout(&format!("\
{compiling} foo v0.0.1 ({dir})
",
compiling = COMPILING,
- dir = p.url()).as_slice()));
+ dir = p.url())));
});
test!(test_run_specific_bin_target {
dir = prj.url());
assert_that(prj.cargo_process("test").arg("--bin").arg("bin2"),
- execs().with_status(0).with_stdout(expected_stdout.as_slice()));
+ execs().with_status(0).with_stdout(&expected_stdout));
});
test!(test_run_specific_test_target {
dir = prj.url());
assert_that(prj.cargo_process("test").arg("--test").arg("b"),
- execs().with_status(0).with_stdout(expected_stdout.as_slice()));
+ execs().with_status(0).with_stdout(&expected_stdout));
});
test!(test_no_harness {
assert_that(p.cargo_process("test").arg("--").arg("--nocapture"),
execs().with_status(0)
- .with_stdout(format!("\
+ .with_stdout(&format!("\
{compiling} foo v0.0.1 ({dir})
{running} target[..]bar-[..]
",
compiling = COMPILING, running = RUNNING,
- dir = p.url()).as_slice()));
+ dir = p.url())));
});
test!(selective_testing {
println!("d1");
assert_that(p.cargo("test").arg("-p").arg("d1"),
execs().with_status(0)
- .with_stdout(format!("\
+ .with_stdout(&format!("\
{compiling} d1 v0.0.1 ({dir})
{running} target[..]d1-[..]
test result: ok. 0 passed; 0 failed; 0 ignored; 0 measured
", compiling = COMPILING, running = RUNNING,
- dir = p.url()).as_slice()));
+ dir = p.url())));
println!("d2");
assert_that(p.cargo("test").arg("-p").arg("d2"),
execs().with_status(0)
- .with_stdout(format!("\
+ .with_stdout(&format!("\
{compiling} d2 v0.0.1 ({dir})
{running} target[..]d2-[..]
test result: ok. 0 passed; 0 failed; 0 ignored; 0 measured
", compiling = COMPILING, running = RUNNING,
- dir = p.url()).as_slice()));
+ dir = p.url())));
println!("whole");
assert_that(p.cargo("test"),
execs().with_status(0)
- .with_stdout(format!("\
+ .with_stdout(&format!("\
{compiling} foo v0.0.1 ({dir})
{running} target[..]foo-[..]
test result: ok. 0 passed; 0 failed; 0 ignored; 0 measured
", compiling = COMPILING, running = RUNNING,
- dir = p.url()).as_slice()));
+ dir = p.url())));
});
test!(almost_cyclic_but_not_quite {
assert_that(p.cargo("test").arg("-p").arg("d1"),
execs().with_status(0)
- .with_stdout(format!("\
+ .with_stdout(&format!("\
{compiling} d1 v0.0.1 ({dir})
{running} target[..]deps[..]d1[..]
test result: ok. 0 passed; 0 failed; 0 ignored; 0 measured
", compiling = COMPILING, running = RUNNING, dir = p.url(),
- doctest = DOCTEST).as_slice()));
+ doctest = DOCTEST)));
});
test!(example_bin_same_name {
assert_that(p.cargo_process("test").arg("--no-run").arg("-v"),
execs().with_status(0)
- .with_stdout(format!("\
+ .with_stdout(&format!("\
{compiling} foo v0.0.1 ({dir})
{running} `rustc [..]`
{running} `rustc [..]`
-", compiling = COMPILING, running = RUNNING, dir = p.url()).as_slice()));
+", compiling = COMPILING, running = RUNNING, dir = p.url())));
assert_that(&p.bin("foo"), is_not(existing_file()));
assert_that(&p.bin("examples/foo"), existing_file());
assert_that(p.cargo("run"),
execs().with_status(0)
- .with_stdout(format!("\
+ .with_stdout(&format!("\
{compiling} foo v0.0.1 ([..])
{running} [..]
bin
-", compiling = COMPILING, running = RUNNING).as_slice()));
+", compiling = COMPILING, running = RUNNING)));
assert_that(&p.bin("foo"), existing_file());
});
assert_that(p.cargo_process("test").arg("-v"),
execs().with_status(0)
- .with_stdout(format!("\
+ .with_stdout(&format!("\
[..]
[..]
[..]
[..]
{running} `rustc [..] --crate-name ex [..] --extern a=[..]`
-", running = RUNNING).as_slice()));
+", running = RUNNING)));
});
test!(bin_is_preserved {
let p = project("foo");
assert_that(p.cargo_process("version"),
- execs().with_status(0).with_stdout(format!("{}\n",
- cargo::version()).as_slice()));
+ execs().with_status(0).with_stdout(&format!("{}\n",
+ cargo::version())));
assert_that(p.cargo_process("--version"),
- execs().with_status(0).with_stdout(format!("{}\n",
- cargo::version()).as_slice()));
+ execs().with_status(0).with_stdout(&format!("{}\n",
+ cargo::version())));
});
-#![feature(core, io, old_io)]
+#![feature(io, convert, thread_sleep)]
#![feature(std_misc, io, fs, fs_ext, path_ext, fs_time, fs_walk)]
-extern crate "rustc-serialize" as serialize;
+extern crate rustc_serialize;
extern crate cargo;
extern crate flate2;
extern crate git2;
mod test_cargo_version;
mod test_shell;
-#[allow(deprecated)]
fn sleep(dur: std::time::Duration) {
- std::old_io::timer::sleep(dur)
+ std::thread::sleep(dur)
}
projects / cargo.git / commitdiff